a769552055
This reverts commit 61523c45a3.
Reason for revert: https://ci.chromium.org/p/v8/builders/ci/V8%20Win32%20-%20debug/20396
Original change's description:
> Move deoptimizer files
>
> Bug: v8:9247
> Change-Id: I6287907edb8a36225bfa9fe864305ea59c20dd8b
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1617667
> Commit-Queue: Yang Guo <yangguo@chromium.org>
> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
> Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#61648}
TBR=yangguo@chromium.org,mstarzinger@chromium.org,jarin@chromium.org,bmeurer@chromium.org
Change-Id: Icf258f7bc409ef0c360cfa82029bfc45a41dc75f
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: v8:9247
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1619749
Reviewed-by: Yang Guo <yangguo@chromium.org>
Commit-Queue: Yang Guo <yangguo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61650}
4631 lines
153 KiB
C++
4631 lines
153 KiB
C++
// 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
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "src/v8.h"
|
|
|
|
#include "src/api/api-inl.h"
|
|
#include "src/compilation-cache.h"
|
|
#include "src/debug/debug-interface.h"
|
|
#include "src/debug/debug.h"
|
|
#include "src/deoptimizer.h"
|
|
#include "src/frames.h"
|
|
#include "src/objects-inl.h"
|
|
#include "src/snapshot/natives.h"
|
|
#include "src/snapshot/snapshot.h"
|
|
#include "src/utils.h"
|
|
#include "test/cctest/cctest.h"
|
|
|
|
using ::v8::internal::Handle;
|
|
using ::v8::internal::StepNone; // From StepAction enum
|
|
using ::v8::internal::StepIn; // From StepAction enum
|
|
using ::v8::internal::StepNext; // From StepAction enum
|
|
using ::v8::internal::StepOut; // From StepAction enum
|
|
|
|
// --- H e l p e r F u n c t i o n s
|
|
|
|
// Compile and run the supplied source and return the requested function.
|
|
static v8::Local<v8::Function> CompileFunction(v8::Isolate* isolate,
|
|
const char* source,
|
|
const char* function_name) {
|
|
CompileRunChecked(isolate, source);
|
|
v8::Local<v8::String> name = v8_str(isolate, function_name);
|
|
v8::Local<v8::Context> context = isolate->GetCurrentContext();
|
|
v8::MaybeLocal<v8::Value> maybe_function =
|
|
context->Global()->Get(context, name);
|
|
return v8::Local<v8::Function>::Cast(maybe_function.ToLocalChecked());
|
|
}
|
|
|
|
|
|
// Compile and run the supplied source and return the requested function.
|
|
static v8::Local<v8::Function> CompileFunction(LocalContext* env,
|
|
const char* source,
|
|
const char* function_name) {
|
|
return CompileFunction((*env)->GetIsolate(), source, function_name);
|
|
}
|
|
|
|
// Is there any debug info for the function?
|
|
static bool HasBreakInfo(v8::Local<v8::Function> fun) {
|
|
Handle<v8::internal::JSFunction> f =
|
|
Handle<v8::internal::JSFunction>::cast(v8::Utils::OpenHandle(*fun));
|
|
Handle<v8::internal::SharedFunctionInfo> shared(f->shared(), f->GetIsolate());
|
|
return shared->HasBreakInfo();
|
|
}
|
|
|
|
// Set a break point in a function with a position relative to function start,
|
|
// and return the associated break point number.
|
|
static i::Handle<i::BreakPoint> SetBreakPoint(v8::Local<v8::Function> fun,
|
|
int position,
|
|
const char* condition = nullptr) {
|
|
i::Handle<i::JSFunction> function =
|
|
i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*fun));
|
|
position += function->shared()->StartPosition();
|
|
static int break_point_index = 0;
|
|
i::Isolate* isolate = function->GetIsolate();
|
|
i::Handle<i::String> condition_string =
|
|
condition ? isolate->factory()->NewStringFromAsciiChecked(condition)
|
|
: isolate->factory()->empty_string();
|
|
i::Debug* debug = isolate->debug();
|
|
i::Handle<i::BreakPoint> break_point =
|
|
isolate->factory()->NewBreakPoint(++break_point_index, condition_string);
|
|
|
|
debug->SetBreakpoint(handle(function->shared(), isolate), break_point,
|
|
&position);
|
|
return break_point;
|
|
}
|
|
|
|
|
|
static void ClearBreakPoint(i::Handle<i::BreakPoint> break_point) {
|
|
v8::internal::Isolate* isolate = CcTest::i_isolate();
|
|
v8::internal::Debug* debug = isolate->debug();
|
|
debug->ClearBreakPoint(break_point);
|
|
}
|
|
|
|
|
|
// Change break on exception.
|
|
static void ChangeBreakOnException(bool caught, bool uncaught) {
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
debug->ChangeBreakOnException(v8::internal::BreakException, caught);
|
|
debug->ChangeBreakOnException(v8::internal::BreakUncaughtException, uncaught);
|
|
}
|
|
|
|
|
|
// Prepare to step to next break location.
|
|
static void PrepareStep(i::StepAction step_action) {
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
debug->PrepareStep(step_action);
|
|
}
|
|
|
|
// This function is in namespace v8::internal to be friend with class
|
|
// v8::internal::Debug.
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
// Collect the currently debugged functions.
|
|
Handle<FixedArray> GetDebuggedFunctions() {
|
|
Debug* debug = CcTest::i_isolate()->debug();
|
|
|
|
v8::internal::DebugInfoListNode* node = debug->debug_info_list_;
|
|
|
|
// Find the number of debugged functions.
|
|
int count = 0;
|
|
while (node) {
|
|
count++;
|
|
node = node->next();
|
|
}
|
|
|
|
// Allocate array for the debugged functions
|
|
Handle<FixedArray> debugged_functions =
|
|
CcTest::i_isolate()->factory()->NewFixedArray(count);
|
|
|
|
// Run through the debug info objects and collect all functions.
|
|
count = 0;
|
|
while (node) {
|
|
debugged_functions->set(count++, *node->debug_info());
|
|
node = node->next();
|
|
}
|
|
|
|
return debugged_functions;
|
|
}
|
|
|
|
|
|
// Check that the debugger has been fully unloaded.
|
|
void CheckDebuggerUnloaded() {
|
|
// Check that the debugger context is cleared and that there is no debug
|
|
// information stored for the debugger.
|
|
CHECK(!CcTest::i_isolate()->debug()->debug_info_list_);
|
|
|
|
// Collect garbage to ensure weak handles are cleared.
|
|
CcTest::CollectAllGarbage();
|
|
CcTest::CollectAllGarbage();
|
|
|
|
// Iterate the heap and check that there are no debugger related objects left.
|
|
HeapIterator iterator(CcTest::heap());
|
|
for (HeapObject obj = iterator.next(); !obj.is_null();
|
|
obj = iterator.next()) {
|
|
CHECK(!obj->IsDebugInfo());
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace internal
|
|
} // namespace v8
|
|
|
|
|
|
// Check that the debugger has been fully unloaded.
|
|
static void CheckDebuggerUnloaded() { v8::internal::CheckDebuggerUnloaded(); }
|
|
|
|
// --- D e b u g E v e n t H a n d l e r s
|
|
// ---
|
|
// --- The different tests uses a number of debug event handlers.
|
|
// ---
|
|
|
|
// Debug event handler which counts a number of events.
|
|
int break_point_hit_count = 0;
|
|
int break_point_hit_count_deoptimize = 0;
|
|
class DebugEventCounter : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(
|
|
v8::Local<v8::Context>,
|
|
const std::vector<v8::debug::BreakpointId>&) override {
|
|
break_point_hit_count++;
|
|
// Perform a full deoptimization when the specified number of
|
|
// breaks have been hit.
|
|
if (break_point_hit_count == break_point_hit_count_deoptimize) {
|
|
i::Deoptimizer::DeoptimizeAll(CcTest::i_isolate());
|
|
}
|
|
if (step_action_ != StepNone) PrepareStep(step_action_);
|
|
}
|
|
|
|
void set_step_action(i::StepAction step_action) {
|
|
step_action_ = step_action;
|
|
}
|
|
|
|
private:
|
|
i::StepAction step_action_ = StepNone;
|
|
};
|
|
|
|
// Debug event handler which performs a garbage collection.
|
|
class DebugEventBreakPointCollectGarbage : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(
|
|
v8::Local<v8::Context>,
|
|
const std::vector<v8::debug::BreakpointId>&) override {
|
|
// Perform a garbage collection when break point is hit and continue. Based
|
|
// on the number of break points hit either scavenge or mark compact
|
|
// collector is used.
|
|
break_point_hit_count++;
|
|
if (break_point_hit_count % 2 == 0) {
|
|
// Scavenge.
|
|
CcTest::CollectGarbage(v8::internal::NEW_SPACE);
|
|
} else {
|
|
// Mark sweep compact.
|
|
CcTest::CollectAllGarbage();
|
|
}
|
|
}
|
|
};
|
|
|
|
// Debug event handler which re-issues a debug break and calls the garbage
|
|
// collector to have the heap verified.
|
|
class DebugEventBreak : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(
|
|
v8::Local<v8::Context>,
|
|
const std::vector<v8::debug::BreakpointId>&) override {
|
|
// Count the number of breaks.
|
|
break_point_hit_count++;
|
|
|
|
// Run the garbage collector to enforce heap verification if option
|
|
// --verify-heap is set.
|
|
CcTest::CollectGarbage(v8::internal::NEW_SPACE);
|
|
|
|
// Set the break flag again to come back here as soon as possible.
|
|
v8::debug::SetBreakOnNextFunctionCall(CcTest::isolate());
|
|
}
|
|
};
|
|
|
|
static void BreakRightNow(v8::Isolate* isolate, void*) {
|
|
v8::debug::BreakRightNow(isolate);
|
|
}
|
|
|
|
// Debug event handler which re-issues a debug break until a limit has been
|
|
// reached.
|
|
int max_break_point_hit_count = 0;
|
|
bool terminate_after_max_break_point_hit = false;
|
|
class DebugEventBreakMax : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(
|
|
v8::Local<v8::Context>,
|
|
const std::vector<v8::debug::BreakpointId>&) override {
|
|
v8::Isolate* v8_isolate = CcTest::isolate();
|
|
v8::internal::Isolate* isolate = CcTest::i_isolate();
|
|
if (break_point_hit_count < max_break_point_hit_count) {
|
|
// Count the number of breaks.
|
|
break_point_hit_count++;
|
|
|
|
// Set the break flag again to come back here as soon as possible.
|
|
v8_isolate->RequestInterrupt(BreakRightNow, nullptr);
|
|
|
|
} else if (terminate_after_max_break_point_hit) {
|
|
// Terminate execution after the last break if requested.
|
|
v8_isolate->TerminateExecution();
|
|
}
|
|
|
|
// Perform a full deoptimization when the specified number of
|
|
// breaks have been hit.
|
|
if (break_point_hit_count == break_point_hit_count_deoptimize) {
|
|
i::Deoptimizer::DeoptimizeAll(isolate);
|
|
}
|
|
}
|
|
};
|
|
|
|
// --- T h e A c t u a l T e s t s
|
|
|
|
// Test that the debug info in the VM is in sync with the functions being
|
|
// debugged.
|
|
TEST(DebugInfo) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
// Create a couple of functions for the test.
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){}", "foo");
|
|
v8::Local<v8::Function> bar =
|
|
CompileFunction(&env, "function bar(){}", "bar");
|
|
// Initially no functions are debugged.
|
|
CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());
|
|
CHECK(!HasBreakInfo(foo));
|
|
CHECK(!HasBreakInfo(bar));
|
|
EnableDebugger(env->GetIsolate());
|
|
// One function (foo) is debugged.
|
|
i::Handle<i::BreakPoint> bp1 = SetBreakPoint(foo, 0);
|
|
CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());
|
|
CHECK(HasBreakInfo(foo));
|
|
CHECK(!HasBreakInfo(bar));
|
|
// Two functions are debugged.
|
|
i::Handle<i::BreakPoint> bp2 = SetBreakPoint(bar, 0);
|
|
CHECK_EQ(2, v8::internal::GetDebuggedFunctions()->length());
|
|
CHECK(HasBreakInfo(foo));
|
|
CHECK(HasBreakInfo(bar));
|
|
// One function (bar) is debugged.
|
|
ClearBreakPoint(bp1);
|
|
CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());
|
|
CHECK(!HasBreakInfo(foo));
|
|
CHECK(HasBreakInfo(bar));
|
|
// No functions are debugged.
|
|
ClearBreakPoint(bp2);
|
|
DisableDebugger(env->GetIsolate());
|
|
CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());
|
|
CHECK(!HasBreakInfo(foo));
|
|
CHECK(!HasBreakInfo(bar));
|
|
}
|
|
|
|
|
|
// Test that a break point can be set at an IC store location.
|
|
TEST(BreakPointICStore) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){bar=0;}", "foo");
|
|
|
|
// Run without breakpoints.
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that a break point can be set at an IC store location.
|
|
TEST(BreakPointCondition) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
CompileRun("var a = false");
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo() { return 1 }", "foo");
|
|
// Run without breakpoints.
|
|
CompileRun("foo()");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0, "a == true");
|
|
CompileRun("foo()");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
CompileRun("a = true");
|
|
CompileRun("foo()");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("foo()");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that a break point can be set at an IC load location.
|
|
TEST(BreakPointICLoad) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
CompileRunChecked(env->GetIsolate(), "bar=1");
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){var x=bar;}", "foo");
|
|
|
|
// Run without breakpoints.
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that a break point can be set at an IC call location.
|
|
TEST(BreakPointICCall) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
CompileRunChecked(env->GetIsolate(), "function bar(){}");
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){bar();}", "foo");
|
|
|
|
// Run without breakpoints.
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that a break point can be set at an IC call location and survive a GC.
|
|
TEST(BreakPointICCallWithGC) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
DebugEventBreakPointCollectGarbage delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
CompileRunChecked(env->GetIsolate(), "function bar(){return 1;}");
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){return bar();}", "foo");
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
// Run without breakpoints.
|
|
CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);
|
|
CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that a break point can be set at an IC call location and survive a GC.
|
|
TEST(BreakPointConstructCallWithGC) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
DebugEventBreakPointCollectGarbage delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
CompileRunChecked(env->GetIsolate(), "function bar(){ this.x = 1;}");
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){return new bar(1).x;}", "foo");
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
// Run without breakpoints.
|
|
CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);
|
|
CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CHECK_EQ(1, foo->Call(context, env->Global(), 0, nullptr)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(BreakPointBuiltin) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test simple builtin ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.prototype.repeat").As<v8::Function>();
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
ExpectString("'b'.repeat(10)", "bbbbbbbbbb");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
ExpectString("'b'.repeat(10)", "bbbbbbbbbb");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectString("'b'.repeat(10)", "bbbbbbbbbb");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointJSBuiltin) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test JS builtin ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("Array.prototype.sort").As<v8::Function>();
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
CompileRun("[1,2,3].sort()");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
CompileRun("[1,2,3].sort()");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("[1,2,3].sort()");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBoundBuiltin) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test bound function from a builtin ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun(
|
|
"var boundrepeat = String.prototype.repeat.bind('a');"
|
|
"String.prototype.repeat")
|
|
.As<v8::Function>();
|
|
ExpectString("boundrepeat(10)", "aaaaaaaaaa");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
ExpectString("boundrepeat(10)", "aaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectString("boundrepeat(10)", "aaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointConstructorBuiltin) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test Promise constructor ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("Promise").As<v8::Function>();
|
|
ExpectString("(new Promise(()=>{})).toString()", "[object Promise]");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
ExpectString("(new Promise(()=>{})).toString()", "[object Promise]");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectString("(new Promise(()=>{})).toString()", "[object Promise]");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// === Test Object constructor ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("Object").As<v8::Function>();
|
|
CompileRun("new Object()");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
CompileRun("new Object()");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("new Object()");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// === Test Number constructor ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("Number").As<v8::Function>();
|
|
CompileRun("new Number()");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
CompileRun("new Number()");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("new Number()");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlinedBuiltin) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test inlined builtin ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("Math.sin").As<v8::Function>();
|
|
CompileRun("function test(x) { return 1 + Math.sin(x) }");
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(test);"
|
|
"test(0.5); test(0.6);"
|
|
"%OptimizeFunctionOnNextCall(test); test(0.7);");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
CompileRun("Math.sin(0.1);");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CompileRun("test(0.2);");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Re-optimize.
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(test);"
|
|
"%OptimizeFunctionOnNextCall(test);");
|
|
ExpectBoolean("test(0.3) < 2", true);
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("test(0.3);");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlineBoundBuiltin) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test inlined bound builtin ===
|
|
break_point_hit_count = 0;
|
|
|
|
builtin = CompileRun(
|
|
"var boundrepeat = String.prototype.repeat.bind('a');"
|
|
"String.prototype.repeat")
|
|
.As<v8::Function>();
|
|
CompileRun("function test(x) { return 'a' + boundrepeat(x) }");
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(test);"
|
|
"test(4); test(5);"
|
|
"%OptimizeFunctionOnNextCall(test); test(6);");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
CompileRun("'a'.repeat(2);");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CompileRun("test(7);");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Re-optimize.
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(f);"
|
|
"%OptimizeFunctionOnNextCall(test);");
|
|
CompileRun("test(8);");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("test(9);");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlinedConstructorBuiltin) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
i::FLAG_experimental_inline_promise_constructor = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test inlined constructor builtin (regular construct builtin) ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("Promise").As<v8::Function>();
|
|
CompileRun("function test(x) { return new Promise(()=>x); }");
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(test);"
|
|
"test(4); test(5);"
|
|
"%OptimizeFunctionOnNextCall(test); test(6);");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
CompileRun("new Promise(()=>{});");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CompileRun("test(7);");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Re-optimize.
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(f);"
|
|
"%OptimizeFunctionOnNextCall(test);");
|
|
CompileRun("test(8);");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("test(9);");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBuiltinConcurrentOpt) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
i::FLAG_block_concurrent_recompilation = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test concurrent optimization ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("Math.sin").As<v8::Function>();
|
|
CompileRun("function test(x) { return 1 + Math.sin(x) }");
|
|
// Trigger concurrent compile job. It is suspended until unblock.
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(test);"
|
|
"test(0.5); test(0.6);"
|
|
"%OptimizeFunctionOnNextCall(test, 'concurrent'); test(0.7);");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
// Have the concurrent compile job finish now.
|
|
CompileRun(
|
|
"%UnblockConcurrentRecompilation();"
|
|
"%GetOptimizationStatus(test, 'sync');");
|
|
CompileRun("test(0.2);");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("test(0.3);");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBuiltinTFOperator) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test builtin represented as operator ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.prototype.indexOf").As<v8::Function>();
|
|
CompileRun("function test(x) { return 1 + 'foo'.indexOf(x) }");
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(f);"
|
|
"test('a'); test('b');"
|
|
"%OptimizeFunctionOnNextCall(test); test('c');");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
CompileRun("'bar'.indexOf('x');");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CompileRun("test('d');");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Re-optimize.
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(f);"
|
|
"%OptimizeFunctionOnNextCall(test);");
|
|
CompileRun("test('e');");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("test('f');");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBuiltinNewContext) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test builtin from a new context ===
|
|
// This does not work with no-snapshot build.
|
|
#ifdef V8_USE_SNAPSHOT
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.prototype.repeat").As<v8::Function>();
|
|
CompileRun("'a'.repeat(10)");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
// Set breakpoint.
|
|
bp = SetBreakPoint(builtin, 0);
|
|
|
|
{
|
|
// Create and use new context after breakpoint has been set.
|
|
v8::HandleScope handle_scope(env->GetIsolate());
|
|
v8::Local<v8::Context> new_context = v8::Context::New(env->GetIsolate());
|
|
v8::Context::Scope context_scope(new_context);
|
|
|
|
// Run with breakpoint.
|
|
CompileRun("'b'.repeat(10)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
CompileRun("'b'.repeat(10)");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("'b'.repeat(10)");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
}
|
|
#endif
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
void NoOpFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
args.GetReturnValue().Set(v8_num(2));
|
|
}
|
|
|
|
TEST(BreakPointApiFunction) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
v8::Local<v8::FunctionTemplate> function_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), NoOpFunctionCallback);
|
|
|
|
v8::Local<v8::Function> function =
|
|
function_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
env->Global()->Set(env.local(), v8_str("f"), function).ToChecked();
|
|
|
|
// === Test simple builtin ===
|
|
break_point_hit_count = 0;
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(function, 0);
|
|
ExpectInt32("f()", 2);
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
ExpectInt32("f()", 2);
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectInt32("f()", 2);
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
void GetWrapperCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
args.GetReturnValue().Set(
|
|
args[0]
|
|
.As<v8::Object>()
|
|
->Get(args.GetIsolate()->GetCurrentContext(), args[1])
|
|
.ToLocalChecked());
|
|
}
|
|
|
|
TEST(BreakPointApiGetter) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
v8::Local<v8::FunctionTemplate> function_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), NoOpFunctionCallback);
|
|
v8::Local<v8::FunctionTemplate> get_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), GetWrapperCallback);
|
|
|
|
v8::Local<v8::Function> function =
|
|
function_template->GetFunction(env.local()).ToLocalChecked();
|
|
v8::Local<v8::Function> get =
|
|
get_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
env->Global()->Set(env.local(), v8_str("f"), function).ToChecked();
|
|
env->Global()->Set(env.local(), v8_str("get_wrapper"), get).ToChecked();
|
|
CompileRun(
|
|
"var o = {};"
|
|
"Object.defineProperty(o, 'f', { get: f, enumerable: true });");
|
|
|
|
// === Test API builtin as getter ===
|
|
break_point_hit_count = 0;
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(function, 0);
|
|
CompileRun("get_wrapper(o, 'f')");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
CompileRun("o.f");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("get_wrapper(o, 'f', 2)");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
void SetWrapperCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
CHECK(args[0]
|
|
.As<v8::Object>()
|
|
->Set(args.GetIsolate()->GetCurrentContext(), args[1], args[2])
|
|
.FromJust());
|
|
}
|
|
|
|
TEST(BreakPointApiSetter) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
v8::Local<v8::FunctionTemplate> function_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), NoOpFunctionCallback);
|
|
v8::Local<v8::FunctionTemplate> set_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), SetWrapperCallback);
|
|
|
|
v8::Local<v8::Function> function =
|
|
function_template->GetFunction(env.local()).ToLocalChecked();
|
|
v8::Local<v8::Function> set =
|
|
set_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
env->Global()->Set(env.local(), v8_str("f"), function).ToChecked();
|
|
env->Global()->Set(env.local(), v8_str("set_wrapper"), set).ToChecked();
|
|
|
|
CompileRun(
|
|
"var o = {};"
|
|
"Object.defineProperty(o, 'f', { set: f, enumerable: true });");
|
|
|
|
// === Test API builtin as setter ===
|
|
break_point_hit_count = 0;
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(function, 0);
|
|
|
|
CompileRun("o.f = 3");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
CompileRun("set_wrapper(o, 'f', 2)");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("o.f = 3");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// === Test API builtin as setter, with condition ===
|
|
break_point_hit_count = 0;
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(function, 0, "arguments[0] == 3");
|
|
CompileRun("set_wrapper(o, 'f', 2)");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
CompileRun("set_wrapper(o, 'f', 3)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
CompileRun("o.f = 3");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("set_wrapper(o, 'f', 2)");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointApiAccessor) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// Create 'foo' class, with a hidden property.
|
|
v8::Local<v8::ObjectTemplate> obj_template =
|
|
v8::ObjectTemplate::New(env->GetIsolate());
|
|
v8::Local<v8::FunctionTemplate> accessor_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), NoOpFunctionCallback);
|
|
obj_template->SetAccessorProperty(v8_str("f"), accessor_template,
|
|
accessor_template);
|
|
v8::Local<v8::Object> obj =
|
|
obj_template->NewInstance(env.local()).ToLocalChecked();
|
|
env->Global()->Set(env.local(), v8_str("o"), obj).ToChecked();
|
|
|
|
v8::Local<v8::Function> function =
|
|
CompileRun("Object.getOwnPropertyDescriptor(o, 'f').set")
|
|
.As<v8::Function>();
|
|
|
|
// === Test API accessor ===
|
|
break_point_hit_count = 0;
|
|
|
|
CompileRun("function get_loop() { for (var i = 0; i < 10; i++) o.f }");
|
|
CompileRun("function set_loop() { for (var i = 0; i < 10; i++) o.f = 2 }");
|
|
|
|
CompileRun("get_loop(); set_loop();"); // Initialize ICs.
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(function, 0);
|
|
|
|
CompileRun("o.f = 3");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
CompileRun("o.f");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
CompileRun("for (var i = 0; i < 10; i++) o.f");
|
|
CHECK_EQ(12, break_point_hit_count);
|
|
|
|
CompileRun("get_loop();");
|
|
CHECK_EQ(22, break_point_hit_count);
|
|
|
|
CompileRun("for (var i = 0; i < 10; i++) o.f = 2");
|
|
CHECK_EQ(32, break_point_hit_count);
|
|
|
|
CompileRun("set_loop();");
|
|
CHECK_EQ(42, break_point_hit_count);
|
|
|
|
// Test that the break point also works when we install the function
|
|
// template on a new property (with a fresh AccessorPair instance).
|
|
v8::Local<v8::ObjectTemplate> baz_template =
|
|
v8::ObjectTemplate::New(env->GetIsolate());
|
|
baz_template->SetAccessorProperty(v8_str("g"), accessor_template,
|
|
accessor_template);
|
|
v8::Local<v8::Object> baz =
|
|
baz_template->NewInstance(env.local()).ToLocalChecked();
|
|
env->Global()->Set(env.local(), v8_str("b"), baz).ToChecked();
|
|
|
|
CompileRun("b.g = 4");
|
|
CHECK_EQ(43, break_point_hit_count);
|
|
|
|
CompileRun("b.g");
|
|
CHECK_EQ(44, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("o.f = 3");
|
|
CompileRun("o.f");
|
|
CHECK_EQ(44, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlineApiFunction) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
v8::Local<v8::FunctionTemplate> function_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), NoOpFunctionCallback);
|
|
|
|
v8::Local<v8::Function> function =
|
|
function_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
env->Global()->Set(env.local(), v8_str("f"), function).ToChecked();
|
|
CompileRun(
|
|
"function g() { return 1 + f(); };"
|
|
"%PrepareFunctionForOptimization(g);");
|
|
|
|
// === Test simple builtin ===
|
|
break_point_hit_count = 0;
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(function, 0);
|
|
ExpectInt32("g()", 3);
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
ExpectInt32("g()", 3);
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
CompileRun("%OptimizeFunctionOnNextCall(g)");
|
|
ExpectInt32("g()", 3);
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectInt32("g()", 3);
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that a break point can be set at a return store location.
|
|
TEST(BreakPointConditionBuiltin) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
i::FLAG_block_concurrent_recompilation = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test global variable ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.prototype.repeat").As<v8::Function>();
|
|
CompileRun("var condition = false");
|
|
CompileRun("'a'.repeat(10)");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0, "condition == true");
|
|
CompileRun("'b'.repeat(10)");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
CompileRun("condition = true");
|
|
CompileRun("'b'.repeat(10)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("'b'.repeat(10)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// === Test arguments ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.prototype.repeat").As<v8::Function>();
|
|
CompileRun("function f(x) { return 'a'.repeat(x * 2); }");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0, "arguments[0] == 20");
|
|
ExpectString("f(5)", "aaaaaaaaaa");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
ExpectString("f(10)", "aaaaaaaaaaaaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectString("f(10)", "aaaaaaaaaaaaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// === Test adapted arguments ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.prototype.repeat").As<v8::Function>();
|
|
CompileRun("function f(x) { return 'a'.repeat(x * 2, x); }");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0,
|
|
"arguments[1] == 10 && arguments[2] == undefined");
|
|
ExpectString("f(5)", "aaaaaaaaaa");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
ExpectString("f(10)", "aaaaaaaaaaaaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectString("f(10)", "aaaaaaaaaaaaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// === Test var-arg builtins ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.fromCharCode").As<v8::Function>();
|
|
CompileRun("function f() { return String.fromCharCode(1, 2, 3); }");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0, "arguments.length == 3 && arguments[1] == 2");
|
|
CompileRun("f(1, 2, 3)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("f(1, 2, 3)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// === Test rest arguments ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.fromCharCode").As<v8::Function>();
|
|
CompileRun("function f(...args) { return String.fromCharCode(...args); }");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0, "arguments.length == 3 && arguments[1] == 2");
|
|
CompileRun("f(1, 2, 3)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
ClearBreakPoint(bp);
|
|
CompileRun("f(1, 3, 3)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("f(1, 2, 3)");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// === Test receiver ===
|
|
break_point_hit_count = 0;
|
|
builtin = CompileRun("String.prototype.repeat").As<v8::Function>();
|
|
CompileRun("function f(x) { return x.repeat(10); }");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
bp = SetBreakPoint(builtin, 0, "this == 'a'");
|
|
ExpectString("f('b')", "bbbbbbbbbb");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
ExpectString("f('a')", "aaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
ExpectString("f('a')", "aaaaaaaaaa");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlining) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Function> inlinee =
|
|
CompileRun("function f(x) { return x*2; } f").As<v8::Function>();
|
|
CompileRun("function test(x) { return 1 + f(x) }");
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(test);"
|
|
"test(0.5); test(0.6);"
|
|
"%OptimizeFunctionOnNextCall(test); test(0.7);");
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Run with breakpoint.
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(inlinee, 0);
|
|
CompileRun("f(0.1);");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CompileRun("test(0.2);");
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Re-optimize.
|
|
CompileRun(
|
|
"%PrepareFunctionForOptimization(test);"
|
|
"%OptimizeFunctionOnNextCall(test);");
|
|
CompileRun("test(0.3);");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
CompileRun("test(0.3);");
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
static void CallWithBreakPoints(v8::Local<v8::Context> context,
|
|
v8::Local<v8::Object> recv,
|
|
v8::Local<v8::Function> f,
|
|
int break_point_count, int call_count) {
|
|
break_point_hit_count = 0;
|
|
for (int i = 0; i < call_count; i++) {
|
|
f->Call(context, recv, 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ((i + 1) * break_point_count, break_point_hit_count);
|
|
}
|
|
}
|
|
|
|
|
|
// Test GC during break point processing.
|
|
TEST(GCDuringBreakPointProcessing) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
DebugEventBreakPointCollectGarbage delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Function> foo;
|
|
|
|
// Test IC store break point with garbage collection.
|
|
foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
CallWithBreakPoints(context, env->Global(), foo, 1, 10);
|
|
|
|
// Test IC load break point with garbage collection.
|
|
foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
CallWithBreakPoints(context, env->Global(), foo, 1, 10);
|
|
|
|
// Test IC call break point with garbage collection.
|
|
foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
CallWithBreakPoints(context, env->Global(), foo, 1, 10);
|
|
|
|
// Test return break point with garbage collection.
|
|
foo = CompileFunction(&env, "function foo(){}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
CallWithBreakPoints(context, env->Global(), foo, 1, 25);
|
|
|
|
// Test debug break slot break point with garbage collection.
|
|
foo = CompileFunction(&env, "function foo(){var a;}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
CallWithBreakPoints(context, env->Global(), foo, 1, 25);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Call the function three times with different garbage collections in between
|
|
// and make sure that the break point survives.
|
|
static void CallAndGC(v8::Local<v8::Context> context,
|
|
v8::Local<v8::Object> recv, v8::Local<v8::Function> f) {
|
|
break_point_hit_count = 0;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
// Call function.
|
|
f->Call(context, recv, 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1 + i * 3, break_point_hit_count);
|
|
|
|
// Scavenge and call function.
|
|
CcTest::CollectGarbage(v8::internal::NEW_SPACE);
|
|
f->Call(context, recv, 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2 + i * 3, break_point_hit_count);
|
|
|
|
// Mark sweep (and perhaps compact) and call function.
|
|
CcTest::CollectAllGarbage();
|
|
f->Call(context, recv, 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(3 + i * 3, break_point_hit_count);
|
|
}
|
|
}
|
|
|
|
|
|
// Test that a break point can be set at a return store location.
|
|
TEST(BreakPointSurviveGC) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Function> foo;
|
|
|
|
// Test IC store break point with garbage collection.
|
|
{
|
|
CompileFunction(&env, "function foo(){}", "foo");
|
|
foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
}
|
|
CallAndGC(context, env->Global(), foo);
|
|
|
|
// Test IC load break point with garbage collection.
|
|
{
|
|
CompileFunction(&env, "function foo(){}", "foo");
|
|
foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
}
|
|
CallAndGC(context, env->Global(), foo);
|
|
|
|
// Test IC call break point with garbage collection.
|
|
{
|
|
CompileFunction(&env, "function foo(){}", "foo");
|
|
foo = CompileFunction(&env,
|
|
"function bar(){};function foo(){bar();}",
|
|
"foo");
|
|
SetBreakPoint(foo, 0);
|
|
}
|
|
CallAndGC(context, env->Global(), foo);
|
|
|
|
// Test return break point with garbage collection.
|
|
{
|
|
CompileFunction(&env, "function foo(){}", "foo");
|
|
foo = CompileFunction(&env, "function foo(){}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
}
|
|
CallAndGC(context, env->Global(), foo);
|
|
|
|
// Test non IC break point with garbage collection.
|
|
{
|
|
CompileFunction(&env, "function foo(){}", "foo");
|
|
foo = CompileFunction(&env, "function foo(){var bar=0;}", "foo");
|
|
SetBreakPoint(foo, 0);
|
|
}
|
|
CallAndGC(context, env->Global(), foo);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that the debugger statement causes a break.
|
|
TEST(DebuggerStatement) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Context> context = env.local();
|
|
v8::Script::Compile(context,
|
|
v8_str(env->GetIsolate(), "function bar(){debugger}"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::Script::Compile(
|
|
context, v8_str(env->GetIsolate(), "function foo(){debugger;debugger;}"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "foo"))
|
|
.ToLocalChecked());
|
|
v8::Local<v8::Function> bar = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "bar"))
|
|
.ToLocalChecked());
|
|
|
|
// Run function with debugger statement
|
|
bar->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Run function with two debugger statement
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test setting a breakpoint on the debugger statement.
|
|
TEST(DebuggerStatementBreakpoint) {
|
|
break_point_hit_count = 0;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Script::Compile(context,
|
|
v8_str(env->GetIsolate(), "function foo(){debugger;}"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "foo"))
|
|
.ToLocalChecked());
|
|
|
|
// The debugger statement triggers breakpoint hit
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, 0);
|
|
|
|
// Set breakpoint does not duplicate hits
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
ClearBreakPoint(bp);
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that the conditional breakpoints work event if code generation from
|
|
// strings is prohibited in the debugee context.
|
|
TEST(ConditionalBreakpointWithCodeGenerationDisallowed) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
v8::Local<v8::Function> foo = CompileFunction(&env,
|
|
"function foo(x) {\n"
|
|
" var s = 'String value2';\n"
|
|
" return s + x;\n"
|
|
"}",
|
|
"foo");
|
|
|
|
// Set conditional breakpoint with condition 'true'.
|
|
SetBreakPoint(foo, 4, "true");
|
|
|
|
break_point_hit_count = 0;
|
|
env->AllowCodeGenerationFromStrings(false);
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Simple test of the stepping mechanism using only store ICs.
|
|
TEST(DebugStepLinear) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Create a function for testing stepping.
|
|
v8::Local<v8::Function> foo = CompileFunction(&env,
|
|
"function foo(){a=1;b=1;c=1;}",
|
|
"foo");
|
|
|
|
// Run foo to allow it to get optimized.
|
|
CompileRun("a=0; b=0; c=0; foo();");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
SetBreakPoint(foo, 3);
|
|
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Context> context = env.local();
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
SetBreakPoint(foo, 3);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Without stepping only active break points are hit.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test of the stepping mechanism for keyed load in a loop.
|
|
TEST(DebugStepKeyedLoadLoop) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
// Create a function for testing stepping of keyed load. The statement 'y=1'
|
|
// is there to have more than one breakable statement in the loop, TODO(315).
|
|
v8::Local<v8::Function> foo = CompileFunction(
|
|
&env,
|
|
"function foo(a) {\n"
|
|
" var x;\n"
|
|
" var len = a.length;\n"
|
|
" for (var i = 0; i < len; i++) {\n"
|
|
" y = 1;\n"
|
|
" x = a[i];\n"
|
|
" }\n"
|
|
"}\n"
|
|
"y=0\n",
|
|
"foo");
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create array [0,1,2,3,4,5,6,7,8,9]
|
|
v8::Local<v8::Array> a = v8::Array::New(env->GetIsolate(), 10);
|
|
for (int i = 0; i < 10; i++) {
|
|
CHECK(a->Set(context, v8::Number::New(env->GetIsolate(), i),
|
|
v8::Number::New(env->GetIsolate(), i))
|
|
.FromJust());
|
|
}
|
|
|
|
// Call function without any break points to ensure inlining is in place.
|
|
const int kArgc = 1;
|
|
v8::Local<v8::Value> args[kArgc] = {a};
|
|
foo->Call(context, env->Global(), kArgc, args).ToLocalChecked();
|
|
|
|
// Set up break point and step through the function.
|
|
SetBreakPoint(foo, 3);
|
|
run_step.set_step_action(StepNext);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), kArgc, args).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(44, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test of the stepping mechanism for keyed store in a loop.
|
|
TEST(DebugStepKeyedStoreLoop) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
// Create a function for testing stepping of keyed store. The statement 'y=1'
|
|
// is there to have more than one breakable statement in the loop, TODO(315).
|
|
v8::Local<v8::Function> foo = CompileFunction(
|
|
&env,
|
|
"function foo(a) {\n"
|
|
" var len = a.length;\n"
|
|
" for (var i = 0; i < len; i++) {\n"
|
|
" y = 1;\n"
|
|
" a[i] = 42;\n"
|
|
" }\n"
|
|
"}\n"
|
|
"y=0\n",
|
|
"foo");
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create array [0,1,2,3,4,5,6,7,8,9]
|
|
v8::Local<v8::Array> a = v8::Array::New(env->GetIsolate(), 10);
|
|
for (int i = 0; i < 10; i++) {
|
|
CHECK(a->Set(context, v8::Number::New(env->GetIsolate(), i),
|
|
v8::Number::New(env->GetIsolate(), i))
|
|
.FromJust());
|
|
}
|
|
|
|
// Call function without any break points to ensure inlining is in place.
|
|
const int kArgc = 1;
|
|
v8::Local<v8::Value> args[kArgc] = {a};
|
|
foo->Call(context, env->Global(), kArgc, args).ToLocalChecked();
|
|
|
|
// Set up break point and step through the function.
|
|
SetBreakPoint(foo, 3);
|
|
run_step.set_step_action(StepNext);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), kArgc, args).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(44, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test of the stepping mechanism for named load in a loop.
|
|
TEST(DebugStepNamedLoadLoop) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping of named load.
|
|
v8::Local<v8::Function> foo = CompileFunction(
|
|
&env,
|
|
"function foo() {\n"
|
|
" var a = [];\n"
|
|
" var s = \"\";\n"
|
|
" for (var i = 0; i < 10; i++) {\n"
|
|
" var v = new V(i, i + 1);\n"
|
|
" v.y;\n"
|
|
" a.length;\n" // Special case: array length.
|
|
" s.length;\n" // Special case: string length.
|
|
" }\n"
|
|
"}\n"
|
|
"function V(x, y) {\n"
|
|
" this.x = x;\n"
|
|
" this.y = y;\n"
|
|
"}\n",
|
|
"foo");
|
|
|
|
// Call function without any break points to ensure inlining is in place.
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Set up break point and step through the function.
|
|
SetBreakPoint(foo, 4);
|
|
run_step.set_step_action(StepNext);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(65, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
static void DoDebugStepNamedStoreLoop(int expected) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
// Create a function for testing stepping of named store.
|
|
v8::Local<v8::Context> context = env.local();
|
|
v8::Local<v8::Function> foo = CompileFunction(
|
|
&env,
|
|
"function foo() {\n"
|
|
" var a = {a:1};\n"
|
|
" for (var i = 0; i < 10; i++) {\n"
|
|
" a.a = 2\n"
|
|
" }\n"
|
|
"}\n",
|
|
"foo");
|
|
|
|
// Call function without any break points to ensure inlining is in place.
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Set up break point and step through the function.
|
|
SetBreakPoint(foo, 3);
|
|
run_step.set_step_action(StepNext);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// With stepping all expected break locations are hit.
|
|
CHECK_EQ(expected, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test of the stepping mechanism for named load in a loop.
|
|
TEST(DebugStepNamedStoreLoop) { DoDebugStepNamedStoreLoop(34); }
|
|
|
|
// Test the stepping mechanism with different ICs.
|
|
TEST(DebugStepLinearMixedICs) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping.
|
|
v8::Local<v8::Function> foo = CompileFunction(&env,
|
|
"function bar() {};"
|
|
"function foo() {"
|
|
" var x;"
|
|
" var index='name';"
|
|
" var y = {};"
|
|
" a=1;b=2;x=a;y[index]=3;x=y[index];bar();}", "foo");
|
|
|
|
// Run functions to allow them to get optimized.
|
|
CompileRun("a=0; b=0; bar(); foo();");
|
|
|
|
SetBreakPoint(foo, 0);
|
|
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(10, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
SetBreakPoint(foo, 0);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Without stepping only active break points are hit.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepDeclarations) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src = "function foo() { "
|
|
" var a;"
|
|
" var b = 1;"
|
|
" var c = foo;"
|
|
" var d = Math.floor;"
|
|
" var e = b + d(1.2);"
|
|
"}"
|
|
"foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
|
|
SetBreakPoint(foo, 0);
|
|
|
|
// Stepping through the declarations.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(5, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepLocals) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src = "function foo() { "
|
|
" var a,b;"
|
|
" a = 1;"
|
|
" b = a + 2;"
|
|
" b = 1 + 2 + 3;"
|
|
" a = Math.floor(b);"
|
|
"}"
|
|
"foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
|
|
SetBreakPoint(foo, 0);
|
|
|
|
// Stepping through the declarations.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(5, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepIf) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const int argc = 1;
|
|
const char* src = "function foo(x) { "
|
|
" a = 1;"
|
|
" if (x) {"
|
|
" b = 1;"
|
|
" } else {"
|
|
" c = 1;"
|
|
" d = 1;"
|
|
" }"
|
|
"}"
|
|
"a=0; b=0; c=0; d=0; foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
SetBreakPoint(foo, 0);
|
|
|
|
// Stepping through the true part.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_true[argc] = {v8::True(isolate)};
|
|
foo->Call(context, env->Global(), argc, argv_true).ToLocalChecked();
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
|
|
// Stepping through the false part.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_false[argc] = {v8::False(isolate)};
|
|
foo->Call(context, env->Global(), argc, argv_false).ToLocalChecked();
|
|
CHECK_EQ(5, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepSwitch) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const int argc = 1;
|
|
const char* src = "function foo(x) { "
|
|
" a = 1;"
|
|
" switch (x) {"
|
|
" case 1:"
|
|
" b = 1;"
|
|
" case 2:"
|
|
" c = 1;"
|
|
" break;"
|
|
" case 3:"
|
|
" d = 1;"
|
|
" e = 1;"
|
|
" f = 1;"
|
|
" break;"
|
|
" }"
|
|
"}"
|
|
"a=0; b=0; c=0; d=0; e=0; f=0; foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
SetBreakPoint(foo, 0);
|
|
|
|
// One case with fall-through.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_1[argc] = {v8::Number::New(isolate, 1)};
|
|
foo->Call(context, env->Global(), argc, argv_1).ToLocalChecked();
|
|
CHECK_EQ(6, break_point_hit_count);
|
|
|
|
// Another case.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_2[argc] = {v8::Number::New(isolate, 2)};
|
|
foo->Call(context, env->Global(), argc, argv_2).ToLocalChecked();
|
|
CHECK_EQ(5, break_point_hit_count);
|
|
|
|
// Last case.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_3[argc] = {v8::Number::New(isolate, 3)};
|
|
foo->Call(context, env->Global(), argc, argv_3).ToLocalChecked();
|
|
CHECK_EQ(7, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepWhile) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const int argc = 1;
|
|
const char* src = "function foo(x) { "
|
|
" var a = 0;"
|
|
" while (a < x) {"
|
|
" a++;"
|
|
" }"
|
|
"}"
|
|
"foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
SetBreakPoint(foo, 8); // "var a = 0;"
|
|
|
|
// Looping 0 times. We still should break at the while-condition once.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_0[argc] = {v8::Number::New(isolate, 0)};
|
|
foo->Call(context, env->Global(), argc, argv_0).ToLocalChecked();
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
// Looping 10 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_10[argc] = {v8::Number::New(isolate, 10)};
|
|
foo->Call(context, env->Global(), argc, argv_10).ToLocalChecked();
|
|
CHECK_EQ(23, break_point_hit_count);
|
|
|
|
// Looping 100 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_100[argc] = {v8::Number::New(isolate, 100)};
|
|
foo->Call(context, env->Global(), argc, argv_100).ToLocalChecked();
|
|
CHECK_EQ(203, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepDoWhile) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const int argc = 1;
|
|
const char* src = "function foo(x) { "
|
|
" var a = 0;"
|
|
" do {"
|
|
" a++;"
|
|
" } while (a < x)"
|
|
"}"
|
|
"foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
SetBreakPoint(foo, 8); // "var a = 0;"
|
|
|
|
// Looping 0 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_0[argc] = {v8::Number::New(isolate, 0)};
|
|
foo->Call(context, env->Global(), argc, argv_0).ToLocalChecked();
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
|
|
// Looping 10 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_10[argc] = {v8::Number::New(isolate, 10)};
|
|
foo->Call(context, env->Global(), argc, argv_10).ToLocalChecked();
|
|
CHECK_EQ(22, break_point_hit_count);
|
|
|
|
// Looping 100 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_100[argc] = {v8::Number::New(isolate, 100)};
|
|
foo->Call(context, env->Global(), argc, argv_100).ToLocalChecked();
|
|
CHECK_EQ(202, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepFor) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const int argc = 1;
|
|
const char* src = "function foo(x) { "
|
|
" a = 1;"
|
|
" for (i = 0; i < x; i++) {"
|
|
" b = 1;"
|
|
" }"
|
|
"}"
|
|
"a=0; b=0; i=0; foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
|
|
SetBreakPoint(foo, 8); // "a = 1;"
|
|
|
|
// Looping 0 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_0[argc] = {v8::Number::New(isolate, 0)};
|
|
foo->Call(context, env->Global(), argc, argv_0).ToLocalChecked();
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
|
|
// Looping 10 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_10[argc] = {v8::Number::New(isolate, 10)};
|
|
foo->Call(context, env->Global(), argc, argv_10).ToLocalChecked();
|
|
CHECK_EQ(34, break_point_hit_count);
|
|
|
|
// Looping 100 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_100[argc] = {v8::Number::New(isolate, 100)};
|
|
foo->Call(context, env->Global(), argc, argv_100).ToLocalChecked();
|
|
CHECK_EQ(304, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepForContinue) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const int argc = 1;
|
|
const char* src = "function foo(x) { "
|
|
" var a = 0;"
|
|
" var b = 0;"
|
|
" var c = 0;"
|
|
" for (var i = 0; i < x; i++) {"
|
|
" a++;"
|
|
" if (a % 2 == 0) continue;"
|
|
" b++;"
|
|
" c++;"
|
|
" }"
|
|
" return b;"
|
|
"}"
|
|
"foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
v8::Local<v8::Value> result;
|
|
SetBreakPoint(foo, 8); // "var a = 0;"
|
|
|
|
// Each loop generates 4 or 5 steps depending on whether a is equal.
|
|
|
|
// Looping 10 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_10[argc] = {v8::Number::New(isolate, 10)};
|
|
result = foo->Call(context, env->Global(), argc, argv_10).ToLocalChecked();
|
|
CHECK_EQ(5, result->Int32Value(context).FromJust());
|
|
CHECK_EQ(62, break_point_hit_count);
|
|
|
|
// Looping 100 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_100[argc] = {v8::Number::New(isolate, 100)};
|
|
result = foo->Call(context, env->Global(), argc, argv_100).ToLocalChecked();
|
|
CHECK_EQ(50, result->Int32Value(context).FromJust());
|
|
CHECK_EQ(557, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepForBreak) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const int argc = 1;
|
|
const char* src = "function foo(x) { "
|
|
" var a = 0;"
|
|
" var b = 0;"
|
|
" var c = 0;"
|
|
" for (var i = 0; i < 1000; i++) {"
|
|
" a++;"
|
|
" if (a == x) break;"
|
|
" b++;"
|
|
" c++;"
|
|
" }"
|
|
" return b;"
|
|
"}"
|
|
"foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
v8::Local<v8::Value> result;
|
|
SetBreakPoint(foo, 8); // "var a = 0;"
|
|
|
|
// Each loop generates 5 steps except for the last (when break is executed)
|
|
// which only generates 4.
|
|
|
|
// Looping 10 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_10[argc] = {v8::Number::New(isolate, 10)};
|
|
result = foo->Call(context, env->Global(), argc, argv_10).ToLocalChecked();
|
|
CHECK_EQ(9, result->Int32Value(context).FromJust());
|
|
CHECK_EQ(64, break_point_hit_count);
|
|
|
|
// Looping 100 times.
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Value> argv_100[argc] = {v8::Number::New(isolate, 100)};
|
|
result = foo->Call(context, env->Global(), argc, argv_100).ToLocalChecked();
|
|
CHECK_EQ(99, result->Int32Value(context).FromJust());
|
|
CHECK_EQ(604, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepForIn) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
v8::Local<v8::Function> foo;
|
|
const char* src_1 = "function foo() { "
|
|
" var a = [1, 2];"
|
|
" for (x in a) {"
|
|
" b = 0;"
|
|
" }"
|
|
"}"
|
|
"foo()";
|
|
foo = CompileFunction(&env, src_1, "foo");
|
|
SetBreakPoint(foo, 0); // "var a = ..."
|
|
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(8, break_point_hit_count);
|
|
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src_2 = "function foo() { "
|
|
" var a = {a:[1, 2, 3]};"
|
|
" for (x in a.a) {"
|
|
" b = 0;"
|
|
" }"
|
|
"}"
|
|
"foo()";
|
|
foo = CompileFunction(&env, src_2, "foo");
|
|
SetBreakPoint(foo, 0); // "var a = ..."
|
|
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(10, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepWith) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src = "function foo(x) { "
|
|
" var a = {};"
|
|
" with (a) {}"
|
|
" with (b) {}"
|
|
"}"
|
|
"foo()";
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(env->GetIsolate(), "b"),
|
|
v8::Object::New(env->GetIsolate()))
|
|
.FromJust());
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
v8::Local<v8::Value> result;
|
|
SetBreakPoint(foo, 8); // "var a = {};"
|
|
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugConditional) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src =
|
|
"function foo(x) { "
|
|
" return x ? 1 : 2;"
|
|
"}"
|
|
"foo()";
|
|
v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
|
|
SetBreakPoint(foo, 0); // "var a;"
|
|
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
const int argc = 1;
|
|
v8::Local<v8::Value> argv_true[argc] = {v8::True(isolate)};
|
|
foo->Call(context, env->Global(), argc, argv_true).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that step in does not step into native functions.
|
|
TEST(DebugStepNatives) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Create a function for testing stepping.
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){debugger;Math.sin(1);}", "foo");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Without stepping only active break points are hit.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that step in works with function.apply.
|
|
TEST(DebugStepFunctionApply) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Create a function for testing stepping.
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env,
|
|
"function bar(x, y, z) { if (x == 1) { a = y; b = z; } }"
|
|
"function foo(){ debugger; bar.apply(this, [1,2,3]); }",
|
|
"foo");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
run_step.set_step_action(StepIn);
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(7, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Without stepping only the debugger statement is hit.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that step in works with function.call.
|
|
TEST(DebugStepFunctionCall) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping.
|
|
v8::Local<v8::Function> foo = CompileFunction(
|
|
&env,
|
|
"function bar(x, y, z) { if (x == 1) { a = y; b = z; } }"
|
|
"function foo(a){ debugger;"
|
|
" if (a) {"
|
|
" bar.call(this, 1, 2, 3);"
|
|
" } else {"
|
|
" bar.call(this, 0);"
|
|
" }"
|
|
"}",
|
|
"foo");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
run_step.set_step_action(StepIn);
|
|
|
|
// Check stepping where the if condition in bar is false.
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(6, break_point_hit_count);
|
|
|
|
// Check stepping where the if condition in bar is true.
|
|
break_point_hit_count = 0;
|
|
const int argc = 1;
|
|
v8::Local<v8::Value> argv[argc] = {v8::True(isolate)};
|
|
foo->Call(context, env->Global(), argc, argv).ToLocalChecked();
|
|
CHECK_EQ(8, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Without stepping only the debugger statement is hit.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that step in works with Function.call.apply.
|
|
TEST(DebugStepFunctionCallApply) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping.
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env,
|
|
"function bar() { }"
|
|
"function foo(){ debugger;"
|
|
" Function.call.apply(bar);"
|
|
" Function.call.apply(Function.call, "
|
|
"[Function.call, bar]);"
|
|
"}",
|
|
"foo");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventCounter run_step;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &run_step);
|
|
run_step.set_step_action(StepIn);
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(6, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Without stepping only the debugger statement is hit.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Tests that breakpoint will be hit if it's set in script.
|
|
TEST(PauseInScript) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
|
|
|
|
// Register a debug event listener which counts.
|
|
DebugEventCounter event_counter;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &event_counter);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a script that returns a function.
|
|
const char* src = "(function (evt) {})";
|
|
const char* script_name = "StepInHandlerTest";
|
|
|
|
v8::ScriptOrigin origin(v8_str(env->GetIsolate(), script_name),
|
|
v8::Integer::New(env->GetIsolate(), 0));
|
|
v8::Local<v8::Script> script =
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), src), &origin)
|
|
.ToLocalChecked();
|
|
|
|
// Set breakpoint in the script.
|
|
i::Handle<i::Script> i_script(
|
|
i::Script::cast(v8::Utils::OpenHandle(*script)->shared()->script()),
|
|
isolate);
|
|
i::Handle<i::String> condition = isolate->factory()->empty_string();
|
|
int position = 0;
|
|
int id;
|
|
isolate->debug()->SetBreakPointForScript(i_script, condition, &position, &id);
|
|
break_point_hit_count = 0;
|
|
|
|
v8::Local<v8::Value> r = script->Run(context).ToLocalChecked();
|
|
|
|
CHECK(r->IsFunction());
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Get rid of the debug delegate.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
int message_callback_count = 0;
|
|
|
|
TEST(DebugBreak) {
|
|
i::FLAG_stress_compaction = false;
|
|
#ifdef VERIFY_HEAP
|
|
i::FLAG_verify_heap = true;
|
|
#endif
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugEventBreak delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping.
|
|
const char* src = "function f0() {}"
|
|
"function f1(x1) {}"
|
|
"function f2(x1,x2) {}"
|
|
"function f3(x1,x2,x3) {}";
|
|
v8::Local<v8::Function> f0 = CompileFunction(&env, src, "f0");
|
|
v8::Local<v8::Function> f1 = CompileFunction(&env, src, "f1");
|
|
v8::Local<v8::Function> f2 = CompileFunction(&env, src, "f2");
|
|
v8::Local<v8::Function> f3 = CompileFunction(&env, src, "f3");
|
|
|
|
// Call the function to make sure it is compiled.
|
|
v8::Local<v8::Value> argv[] = {
|
|
v8::Number::New(isolate, 1), v8::Number::New(isolate, 1),
|
|
v8::Number::New(isolate, 1), v8::Number::New(isolate, 1)};
|
|
|
|
// Call all functions to make sure that they are compiled.
|
|
f0->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
f1->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
f2->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
f3->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
|
|
// Call all functions with different argument count.
|
|
break_point_hit_count = 0;
|
|
for (unsigned int i = 0; i < arraysize(argv); i++) {
|
|
f0->Call(context, env->Global(), i, argv).ToLocalChecked();
|
|
f1->Call(context, env->Global(), i, argv).ToLocalChecked();
|
|
f2->Call(context, env->Global(), i, argv).ToLocalChecked();
|
|
f3->Call(context, env->Global(), i, argv).ToLocalChecked();
|
|
}
|
|
|
|
// One break for each function called.
|
|
CHECK_EQ(4 * arraysize(argv), break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
class DebugScopingListener : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(
|
|
v8::Local<v8::Context>,
|
|
const std::vector<v8::debug::BreakpointId>&) override {
|
|
auto stack_traces =
|
|
v8::debug::StackTraceIterator::Create(CcTest::isolate());
|
|
v8::debug::Location location = stack_traces->GetSourceLocation();
|
|
CHECK_EQ(26, location.GetColumnNumber());
|
|
CHECK_EQ(0, location.GetLineNumber());
|
|
|
|
auto scopes = stack_traces->GetScopeIterator();
|
|
CHECK_EQ(v8::debug::ScopeIterator::ScopeTypeWith, scopes->GetType());
|
|
CHECK_EQ(20, scopes->GetStartLocation().GetColumnNumber());
|
|
CHECK_EQ(31, scopes->GetEndLocation().GetColumnNumber());
|
|
|
|
scopes->Advance();
|
|
CHECK_EQ(v8::debug::ScopeIterator::ScopeTypeLocal, scopes->GetType());
|
|
CHECK_EQ(0, scopes->GetStartLocation().GetColumnNumber());
|
|
CHECK_EQ(68, scopes->GetEndLocation().GetColumnNumber());
|
|
|
|
scopes->Advance();
|
|
CHECK_EQ(v8::debug::ScopeIterator::ScopeTypeGlobal, scopes->GetType());
|
|
|
|
scopes->Advance();
|
|
CHECK(scopes->Done());
|
|
}
|
|
};
|
|
|
|
TEST(DebugBreakInWrappedScript) {
|
|
i::FLAG_stress_compaction = false;
|
|
#ifdef VERIFY_HEAP
|
|
i::FLAG_verify_heap = true;
|
|
#endif
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugScopingListener delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
|
|
static const char* source =
|
|
// 0 1 2 3 4 5 6 7
|
|
"try { with({o : []}){ o[0](); } } catch (e) { return e.toString(); }";
|
|
static const char* expect = "TypeError: o[0] is not a function";
|
|
|
|
// For this test, we want to break on uncaught exceptions:
|
|
ChangeBreakOnException(true, true);
|
|
|
|
{
|
|
v8::ScriptCompiler::Source script_source(v8_str(source));
|
|
v8::Local<v8::Function> fun =
|
|
v8::ScriptCompiler::CompileFunctionInContext(
|
|
env.local(), &script_source, 0, nullptr, 0, nullptr)
|
|
.ToLocalChecked();
|
|
v8::Local<v8::Value> result =
|
|
fun->Call(env.local(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK(result->IsString());
|
|
CHECK(v8::Local<v8::String>::Cast(result)
|
|
->Equals(env.local(), v8_str(expect))
|
|
.FromJust());
|
|
}
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
static void EmptyHandler(const v8::FunctionCallbackInfo<v8::Value>& args) {}
|
|
|
|
TEST(DebugScopeIteratorWithFunctionTemplate) {
|
|
LocalContext env;
|
|
v8::HandleScope handle_scope(env->GetIsolate());
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
EnableDebugger(isolate);
|
|
v8::Local<v8::Function> func =
|
|
v8::Function::New(env.local(), EmptyHandler).ToLocalChecked();
|
|
std::unique_ptr<v8::debug::ScopeIterator> iterator =
|
|
v8::debug::ScopeIterator::CreateForFunction(isolate, func);
|
|
CHECK(iterator->Done());
|
|
DisableDebugger(isolate);
|
|
}
|
|
|
|
TEST(DebugBreakWithoutJS) {
|
|
i::FLAG_stress_compaction = false;
|
|
#ifdef VERIFY_HEAP
|
|
i::FLAG_verify_heap = true;
|
|
#endif
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugEventBreak delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
|
|
v8::Local<v8::String> json = v8_str("[1]");
|
|
v8::Local<v8::Value> parsed = v8::JSON::Parse(context, json).ToLocalChecked();
|
|
CHECK(v8::JSON::Stringify(context, parsed)
|
|
.ToLocalChecked()
|
|
->Equals(context, json)
|
|
.FromJust());
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
CompileRun("");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test to ensure that JavaScript code keeps running while the debug break
|
|
// through the stack limit flag is set but breaks are disabled.
|
|
TEST(DisableBreak) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
v8::Local<v8::Context> context = env.local();
|
|
// Create a function for testing stepping.
|
|
const char* src = "function f() {g()};function g(){i=0; while(i<10){i++}}";
|
|
v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
|
|
|
|
// Set, test and cancel debug break.
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
v8::debug::ClearBreakOnNextFunctionCall(env->GetIsolate());
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
|
|
// Call all functions with different argument count.
|
|
break_point_hit_count = 0;
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
{
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
|
|
v8::internal::DisableBreak disable_break(isolate->debug());
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
}
|
|
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(DisableDebuggerStatement) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
CompileRun("debugger;");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Check that we ignore debugger statement when breakpoints aren't active.
|
|
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
|
|
isolate->debug()->set_break_points_active(false);
|
|
CompileRun("debugger;");
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
}
|
|
|
|
static const char* kSimpleExtensionSource =
|
|
"(function Foo() {"
|
|
" return 4;"
|
|
"})() ";
|
|
|
|
// http://crbug.com/28933
|
|
// Test that debug break is disabled when bootstrapper is active.
|
|
TEST(NoBreakWhenBootstrapping) {
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::SetBreakOnNextFunctionCall(isolate);
|
|
break_point_hit_count = 0;
|
|
{
|
|
// Create a context with an extension to make sure that some JavaScript
|
|
// code is executed during bootstrapping.
|
|
v8::RegisterExtension(v8::base::make_unique<v8::Extension>(
|
|
"simpletest", kSimpleExtensionSource));
|
|
const char* extension_names[] = { "simpletest" };
|
|
v8::ExtensionConfiguration extensions(1, extension_names);
|
|
v8::HandleScope handle_scope(isolate);
|
|
v8::Context::New(isolate, &extensions);
|
|
}
|
|
// Check that no DebugBreak events occurred during the context creation.
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(SetDebugEventListenerOnUninitializedVM) {
|
|
v8::HandleScope scope(CcTest::isolate());
|
|
EnableDebugger(CcTest::isolate());
|
|
}
|
|
|
|
// Test that clearing the debug event listener actually clears all break points
|
|
// and related information.
|
|
TEST(DebuggerUnload) {
|
|
LocalContext env;
|
|
v8::HandleScope handle_scope(env->GetIsolate());
|
|
// Check debugger is unloaded before it is used.
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Set a debug event listener.
|
|
break_point_hit_count = 0;
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Context> context = env.local();
|
|
{
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
// Create a couple of functions for the test.
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){x=1}", "foo");
|
|
v8::Local<v8::Function> bar =
|
|
CompileFunction(&env, "function bar(){y=2}", "bar");
|
|
|
|
// Set some break points.
|
|
SetBreakPoint(foo, 0);
|
|
SetBreakPoint(foo, 4);
|
|
SetBreakPoint(bar, 0);
|
|
SetBreakPoint(bar, 4);
|
|
|
|
// Make sure that the break points are there.
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
bar->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
}
|
|
|
|
// Remove the debug event listener without clearing breakpoints. Do this
|
|
// outside a handle scope.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
int event_listener_hit_count = 0;
|
|
|
|
// Test for issue http://code.google.com/p/v8/issues/detail?id=289.
|
|
// Make sure that DebugGetLoadedScripts doesn't return scripts
|
|
// with disposed external source.
|
|
class EmptyExternalStringResource : public v8::String::ExternalStringResource {
|
|
public:
|
|
EmptyExternalStringResource() { empty_[0] = 0; }
|
|
~EmptyExternalStringResource() override = default;
|
|
size_t length() const override { return empty_.length(); }
|
|
const uint16_t* data() const override { return empty_.begin(); }
|
|
|
|
private:
|
|
::v8::internal::EmbeddedVector<uint16_t, 1> empty_;
|
|
};
|
|
|
|
TEST(DebugScriptLineEndsAreAscending) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Compile a test script.
|
|
v8::Local<v8::String> script = v8_str(isolate,
|
|
"function f() {\n"
|
|
" debugger;\n"
|
|
"}\n");
|
|
|
|
v8::ScriptOrigin origin1 = v8::ScriptOrigin(v8_str(isolate, "name"));
|
|
v8::Local<v8::Script> script1 =
|
|
v8::Script::Compile(env.local(), script, &origin1).ToLocalChecked();
|
|
USE(script1);
|
|
|
|
Handle<v8::internal::FixedArray> instances;
|
|
{
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
instances = debug->GetLoadedScripts();
|
|
}
|
|
|
|
CHECK_GT(instances->length(), 0);
|
|
for (int i = 0; i < instances->length(); i++) {
|
|
Handle<v8::internal::Script> script = Handle<v8::internal::Script>(
|
|
v8::internal::Script::cast(instances->get(i)), CcTest::i_isolate());
|
|
|
|
v8::internal::Script::InitLineEnds(script);
|
|
v8::internal::FixedArray ends =
|
|
v8::internal::FixedArray::cast(script->line_ends());
|
|
CHECK_GT(ends->length(), 0);
|
|
|
|
int prev_end = -1;
|
|
for (int j = 0; j < ends->length(); j++) {
|
|
const int curr_end = v8::internal::Smi::ToInt(ends->get(j));
|
|
CHECK_GT(curr_end, prev_end);
|
|
prev_end = curr_end;
|
|
}
|
|
}
|
|
}
|
|
|
|
static v8::Local<v8::Context> expected_context;
|
|
static v8::Local<v8::Value> expected_context_data;
|
|
|
|
class ContextCheckEventListener : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(v8::Local<v8::Context> paused_context,
|
|
const std::vector<v8::debug::BreakpointId>&
|
|
inspector_break_points_hit) override {
|
|
CheckContext();
|
|
}
|
|
void ScriptCompiled(v8::Local<v8::debug::Script> script, bool is_live_edited,
|
|
bool has_compile_error) override {
|
|
CheckContext();
|
|
}
|
|
void ExceptionThrown(v8::Local<v8::Context> paused_context,
|
|
v8::Local<v8::Value> exception,
|
|
v8::Local<v8::Value> promise, bool is_uncaught,
|
|
v8::debug::ExceptionType) override {
|
|
CheckContext();
|
|
}
|
|
bool IsFunctionBlackboxed(v8::Local<v8::debug::Script> script,
|
|
const v8::debug::Location& start,
|
|
const v8::debug::Location& end) override {
|
|
CheckContext();
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
void CheckContext() {
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
CHECK(context == expected_context);
|
|
CHECK(context->GetEmbedderData(0)->StrictEquals(expected_context_data));
|
|
event_listener_hit_count++;
|
|
}
|
|
};
|
|
|
|
// Test which creates two contexts and sets different embedder data on each.
|
|
// Checks that this data is set correctly and that when the debug event
|
|
// listener is called the expected context is the one active.
|
|
TEST(ContextData) {
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Create two contexts.
|
|
v8::Local<v8::Context> context_1;
|
|
v8::Local<v8::Context> context_2;
|
|
v8::Local<v8::ObjectTemplate> global_template =
|
|
v8::Local<v8::ObjectTemplate>();
|
|
v8::Local<v8::Value> global_object = v8::Local<v8::Value>();
|
|
context_1 =
|
|
v8::Context::New(isolate, nullptr, global_template, global_object);
|
|
context_2 =
|
|
v8::Context::New(isolate, nullptr, global_template, global_object);
|
|
|
|
ContextCheckEventListener delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
|
|
// Default data value is undefined.
|
|
CHECK_EQ(0, context_1->GetNumberOfEmbedderDataFields());
|
|
CHECK_EQ(0, context_2->GetNumberOfEmbedderDataFields());
|
|
|
|
// Set and check different data values.
|
|
v8::Local<v8::String> data_1 = v8_str(isolate, "1");
|
|
v8::Local<v8::String> data_2 = v8_str(isolate, "2");
|
|
context_1->SetEmbedderData(0, data_1);
|
|
context_2->SetEmbedderData(0, data_2);
|
|
CHECK(context_1->GetEmbedderData(0)->StrictEquals(data_1));
|
|
CHECK(context_2->GetEmbedderData(0)->StrictEquals(data_2));
|
|
|
|
// Simple test function which causes a break.
|
|
const char* source = "function f() { debugger; }";
|
|
|
|
// Enter and run function in the first context.
|
|
{
|
|
v8::Context::Scope context_scope(context_1);
|
|
expected_context = context_1;
|
|
expected_context_data = data_1;
|
|
v8::Local<v8::Function> f = CompileFunction(isolate, source, "f");
|
|
f->Call(context_1, context_1->Global(), 0, nullptr).ToLocalChecked();
|
|
}
|
|
|
|
// Enter and run function in the second context.
|
|
{
|
|
v8::Context::Scope context_scope(context_2);
|
|
expected_context = context_2;
|
|
expected_context_data = data_2;
|
|
v8::Local<v8::Function> f = CompileFunction(isolate, source, "f");
|
|
f->Call(context_2, context_2->Global(), 0, nullptr).ToLocalChecked();
|
|
}
|
|
|
|
// Two times compile event and two times break event.
|
|
CHECK_GT(event_listener_hit_count, 3);
|
|
|
|
v8::debug::SetDebugDelegate(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test which creates a context and sets embedder data on it. Checks that this
|
|
// data is set correctly and that when the debug event listener is called for
|
|
// break event in an eval statement the expected context is the one returned by
|
|
// Message.GetEventContext.
|
|
TEST(EvalContextData) {
|
|
v8::HandleScope scope(CcTest::isolate());
|
|
|
|
v8::Local<v8::Context> context_1;
|
|
v8::Local<v8::ObjectTemplate> global_template =
|
|
v8::Local<v8::ObjectTemplate>();
|
|
context_1 = v8::Context::New(CcTest::isolate(), nullptr, global_template);
|
|
|
|
ContextCheckEventListener delegate;
|
|
v8::debug::SetDebugDelegate(CcTest::isolate(), &delegate);
|
|
|
|
// Contexts initially do not have embedder data fields.
|
|
CHECK_EQ(0, context_1->GetNumberOfEmbedderDataFields());
|
|
|
|
// Set and check a data value.
|
|
v8::Local<v8::String> data_1 = v8_str(CcTest::isolate(), "1");
|
|
context_1->SetEmbedderData(0, data_1);
|
|
CHECK(context_1->GetEmbedderData(0)->StrictEquals(data_1));
|
|
|
|
// Simple test function with eval that causes a break.
|
|
const char* source = "function f() { eval('debugger;'); }";
|
|
|
|
// Enter and run function in the context.
|
|
{
|
|
v8::Context::Scope context_scope(context_1);
|
|
expected_context = context_1;
|
|
expected_context_data = data_1;
|
|
v8::Local<v8::Function> f = CompileFunction(CcTest::isolate(), source, "f");
|
|
f->Call(context_1, context_1->Global(), 0, nullptr).ToLocalChecked();
|
|
}
|
|
|
|
v8::debug::SetDebugDelegate(CcTest::isolate(), nullptr);
|
|
|
|
// One time compile event and one time break event.
|
|
CHECK_GT(event_listener_hit_count, 2);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Debug event listener which counts script compiled events.
|
|
class ScriptCompiledDelegate : public v8::debug::DebugDelegate {
|
|
public:
|
|
void ScriptCompiled(v8::Local<v8::debug::Script>, bool,
|
|
bool has_compile_error) override {
|
|
if (!has_compile_error) {
|
|
after_compile_event_count++;
|
|
} else {
|
|
compile_error_event_count++;
|
|
}
|
|
}
|
|
|
|
int after_compile_event_count = 0;
|
|
int compile_error_event_count = 0;
|
|
};
|
|
|
|
// Tests that after compile event is sent as many times as there are scripts
|
|
// compiled.
|
|
TEST(AfterCompileEventWhenEventListenerIsReset) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
const char* script = "var a=1";
|
|
|
|
ScriptCompiledDelegate delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
|
|
// Setting listener to nullptr should cause debugger unload.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Compilation cache should be disabled when debugger is active.
|
|
CHECK_EQ(2, delegate.after_compile_event_count);
|
|
}
|
|
|
|
// Tests that syntax error event is sent as many times as there are scripts
|
|
// with syntax error compiled.
|
|
TEST(SyntaxErrorEventOnSyntaxException) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// For this test, we want to break on uncaught exceptions:
|
|
ChangeBreakOnException(false, true);
|
|
|
|
ScriptCompiledDelegate delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
// Check initial state.
|
|
CHECK_EQ(0, delegate.compile_error_event_count);
|
|
|
|
// Throws SyntaxError: Unexpected end of input
|
|
CHECK(
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), "+++")).IsEmpty());
|
|
CHECK_EQ(1, delegate.compile_error_event_count);
|
|
|
|
CHECK(v8::Script::Compile(context, v8_str(env->GetIsolate(), "/sel\\/: \\"))
|
|
.IsEmpty());
|
|
CHECK_EQ(2, delegate.compile_error_event_count);
|
|
|
|
v8::Local<v8::Script> script =
|
|
v8::Script::Compile(context,
|
|
v8_str(env->GetIsolate(), "JSON.parse('1234:')"))
|
|
.ToLocalChecked();
|
|
CHECK_EQ(2, delegate.compile_error_event_count);
|
|
CHECK(script->Run(context).IsEmpty());
|
|
CHECK_EQ(3, delegate.compile_error_event_count);
|
|
|
|
v8::Script::Compile(context,
|
|
v8_str(env->GetIsolate(), "new RegExp('/\\/\\\\');"))
|
|
.ToLocalChecked();
|
|
CHECK_EQ(3, delegate.compile_error_event_count);
|
|
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), "throw 1;"))
|
|
.ToLocalChecked();
|
|
CHECK_EQ(3, delegate.compile_error_event_count);
|
|
}
|
|
|
|
// Tests that break event is sent when event listener is reset.
|
|
TEST(BreakEventWhenEventListenerIsReset) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
const char* script = "function f() {};";
|
|
|
|
ScriptCompiledDelegate delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "f"))
|
|
.ToLocalChecked());
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Setting event listener to nullptr should cause debugger unload.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Compilation cache should be disabled when debugger is active.
|
|
CHECK_EQ(1, delegate.after_compile_event_count);
|
|
}
|
|
|
|
// Tests that script is reported as compiled when bound to context.
|
|
TEST(AfterCompileEventOnBindToContext) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope handle_scope(isolate);
|
|
ScriptCompiledDelegate delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
|
|
const char* source = "var a=1";
|
|
v8::ScriptCompiler::Source script_source(
|
|
v8::String::NewFromUtf8(isolate, source, v8::NewStringType::kNormal)
|
|
.ToLocalChecked());
|
|
|
|
v8::Local<v8::UnboundScript> unbound =
|
|
v8::ScriptCompiler::CompileUnboundScript(isolate, &script_source)
|
|
.ToLocalChecked();
|
|
CHECK_EQ(delegate.after_compile_event_count, 0);
|
|
|
|
unbound->BindToCurrentContext();
|
|
CHECK_EQ(delegate.after_compile_event_count, 1);
|
|
v8::debug::SetDebugDelegate(isolate, nullptr);
|
|
}
|
|
|
|
|
|
// Test that if DebugBreak is forced it is ignored when code from
|
|
// debug-delay.js is executed.
|
|
TEST(NoDebugBreakInAfterCompileEventListener) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugEventCounter delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
|
|
// Create a function for testing stepping.
|
|
const char* src = "function f() { eval('var x = 10;'); } ";
|
|
v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
|
|
|
|
// There should be only one break event.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
// Set the debug break flag again.
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
// There should be one more break event when the script is evaluated in 'f'.
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that the debug break flag works with function.apply.
|
|
TEST(DebugBreakFunctionApply) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
|
|
// Create a function for testing breaking in apply.
|
|
v8::Local<v8::Function> foo = CompileFunction(
|
|
&env,
|
|
"function baz(x) { }"
|
|
"function bar(x) { baz(); }"
|
|
"function foo(){ bar.apply(this, [1]); }",
|
|
"foo");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
DebugEventBreakMax delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
// Set the debug break flag before calling the code using function.apply.
|
|
v8::debug::SetBreakOnNextFunctionCall(env->GetIsolate());
|
|
|
|
// Limit the number of debug breaks. This is a regression test for issue 493
|
|
// where this test would enter an infinite loop.
|
|
break_point_hit_count = 0;
|
|
max_break_point_hit_count = 10000; // 10000 => infinite loop.
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// When keeping the debug break several break will happen.
|
|
CHECK_GT(break_point_hit_count, 1);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that setting the terminate execution flag during debug break processing.
|
|
static void TestDebugBreakInLoop(const char* loop_head,
|
|
const char** loop_bodies,
|
|
const char* loop_tail) {
|
|
// Receive 10 breaks for each test and then terminate JavaScript execution.
|
|
static const int kBreaksPerTest = 10;
|
|
|
|
for (int i = 0; loop_bodies[i] != nullptr; i++) {
|
|
// Perform a lazy deoptimization after various numbers of breaks
|
|
// have been hit.
|
|
|
|
i::EmbeddedVector<char, 1024> buffer;
|
|
SNPrintF(buffer, "function f() {%s%s%s}", loop_head, loop_bodies[i],
|
|
loop_tail);
|
|
|
|
i::PrintF("%s\n", buffer.begin());
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
break_point_hit_count_deoptimize = j;
|
|
if (j == 2) {
|
|
break_point_hit_count_deoptimize = kBreaksPerTest;
|
|
}
|
|
|
|
break_point_hit_count = 0;
|
|
max_break_point_hit_count = kBreaksPerTest;
|
|
terminate_after_max_break_point_hit = true;
|
|
|
|
// Function with infinite loop.
|
|
CompileRun(buffer.begin());
|
|
|
|
// Set the debug break to enter the debugger as soon as possible.
|
|
v8::debug::SetBreakOnNextFunctionCall(CcTest::isolate());
|
|
|
|
// Call function with infinite loop.
|
|
CompileRun("f();");
|
|
CHECK_EQ(kBreaksPerTest, break_point_hit_count);
|
|
|
|
CHECK(!CcTest::isolate()->IsExecutionTerminating());
|
|
}
|
|
}
|
|
}
|
|
|
|
static const char* loop_bodies_1[] = {"",
|
|
"g()",
|
|
"if (a == 0) { g() }",
|
|
"if (a == 1) { g() }",
|
|
"if (a == 0) { g() } else { h() }",
|
|
"if (a == 0) { continue }",
|
|
nullptr};
|
|
|
|
static const char* loop_bodies_2[] = {
|
|
"if (a == 1) { continue }",
|
|
"switch (a) { case 1: g(); }",
|
|
"switch (a) { case 1: continue; }",
|
|
"switch (a) { case 1: g(); break; default: h() }",
|
|
"switch (a) { case 1: continue; break; default: h() }",
|
|
nullptr};
|
|
|
|
void DebugBreakLoop(const char* loop_header, const char** loop_bodies,
|
|
const char* loop_footer) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
DebugEventBreakMax delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
CompileRun(
|
|
"var a = 1;\n"
|
|
"function g() { }\n"
|
|
"function h() { }");
|
|
|
|
TestDebugBreakInLoop(loop_header, loop_bodies, loop_footer);
|
|
|
|
// Get rid of the debug event listener.
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInWhileTrue1) {
|
|
DebugBreakLoop("while (true) {", loop_bodies_1, "}");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInWhileTrue2) {
|
|
DebugBreakLoop("while (true) {", loop_bodies_2, "}");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInWhileCondition1) {
|
|
DebugBreakLoop("while (a == 1) {", loop_bodies_1, "}");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInWhileCondition2) {
|
|
DebugBreakLoop("while (a == 1) {", loop_bodies_2, "}");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInDoWhileTrue1) {
|
|
DebugBreakLoop("do {", loop_bodies_1, "} while (true)");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInDoWhileTrue2) {
|
|
DebugBreakLoop("do {", loop_bodies_2, "} while (true)");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInDoWhileCondition1) {
|
|
DebugBreakLoop("do {", loop_bodies_1, "} while (a == 1)");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInDoWhileCondition2) {
|
|
DebugBreakLoop("do {", loop_bodies_2, "} while (a == 1)");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInFor1) { DebugBreakLoop("for (;;) {", loop_bodies_1, "}"); }
|
|
|
|
|
|
TEST(DebugBreakInFor2) { DebugBreakLoop("for (;;) {", loop_bodies_2, "}"); }
|
|
|
|
|
|
TEST(DebugBreakInForCondition1) {
|
|
DebugBreakLoop("for (;a == 1;) {", loop_bodies_1, "}");
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInForCondition2) {
|
|
DebugBreakLoop("for (;a == 1;) {", loop_bodies_2, "}");
|
|
}
|
|
|
|
class DebugBreakInlineListener : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(v8::Local<v8::Context> paused_context,
|
|
const std::vector<v8::debug::BreakpointId>&
|
|
inspector_break_points_hit) override {
|
|
int expected_frame_count = 4;
|
|
int expected_line_number[] = {1, 4, 7, 13};
|
|
|
|
int frame_count = 0;
|
|
auto iterator = v8::debug::StackTraceIterator::Create(CcTest::isolate());
|
|
for (; !iterator->Done(); iterator->Advance(), ++frame_count) {
|
|
v8::debug::Location loc = iterator->GetSourceLocation();
|
|
CHECK_EQ(expected_line_number[frame_count], loc.GetLineNumber());
|
|
}
|
|
CHECK_EQ(frame_count, expected_frame_count);
|
|
}
|
|
};
|
|
|
|
TEST(DebugBreakInline) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.local();
|
|
const char* source =
|
|
"function debug(b) { \n"
|
|
" if (b) debugger; \n"
|
|
"} \n"
|
|
"function f(b) { \n"
|
|
" debug(b) \n"
|
|
"}; \n"
|
|
"function g(b) { \n"
|
|
" f(b); \n"
|
|
"}; \n"
|
|
"%PrepareFunctionForOptimization(g); \n"
|
|
"g(false); \n"
|
|
"g(false); \n"
|
|
"%OptimizeFunctionOnNextCall(g); \n"
|
|
"g(true);";
|
|
DebugBreakInlineListener delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Script> inline_script =
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), source))
|
|
.ToLocalChecked();
|
|
inline_script->Run(context).ToLocalChecked();
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
}
|
|
|
|
static void RunScriptInANewCFrame(const char* source) {
|
|
v8::TryCatch try_catch(CcTest::isolate());
|
|
CompileRun(source);
|
|
CHECK(try_catch.HasCaught());
|
|
}
|
|
|
|
|
|
TEST(Regress131642) {
|
|
// Bug description:
|
|
// When doing StepNext through the first script, the debugger is not reset
|
|
// after exiting through exception. A flawed implementation enabling the
|
|
// debugger to step into Array.prototype.forEach breaks inside the callback
|
|
// for forEach in the second script under the assumption that we are in a
|
|
// recursive call. In an attempt to step out, we crawl the stack using the
|
|
// recorded frame pointer from the first script and fail when not finding it
|
|
// on the stack.
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
DebugEventCounter delegate;
|
|
delegate.set_step_action(StepNext);
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
|
|
// We step through the first script. It exits through an exception. We run
|
|
// this inside a new frame to record a different FP than the second script
|
|
// would expect.
|
|
const char* script_1 = "debugger; throw new Error();";
|
|
RunScriptInANewCFrame(script_1);
|
|
|
|
// The second script uses forEach.
|
|
const char* script_2 = "[0].forEach(function() { });";
|
|
CompileRun(script_2);
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
}
|
|
|
|
class DebugBreakStackTraceListener : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(v8::Local<v8::Context> paused_context,
|
|
const std::vector<v8::debug::BreakpointId>&
|
|
inspector_break_points_hit) override {
|
|
v8::StackTrace::CurrentStackTrace(CcTest::isolate(), 10);
|
|
}
|
|
};
|
|
|
|
static void AddDebugBreak(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::debug::SetBreakOnNextFunctionCall(args.GetIsolate());
|
|
}
|
|
|
|
TEST(DebugBreakStackTrace) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
DebugBreakStackTraceListener delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
v8::Local<v8::Context> context = env.local();
|
|
v8::Local<v8::FunctionTemplate> add_debug_break_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), AddDebugBreak);
|
|
v8::Local<v8::Function> add_debug_break =
|
|
add_debug_break_template->GetFunction(context).ToLocalChecked();
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str("add_debug_break"), add_debug_break)
|
|
.FromJust());
|
|
|
|
CompileRun("(function loop() {"
|
|
" for (var j = 0; j < 1000; j++) {"
|
|
" for (var i = 0; i < 1000; i++) {"
|
|
" if (i == 999) add_debug_break();"
|
|
" }"
|
|
" }"
|
|
"})()");
|
|
}
|
|
|
|
|
|
v8::base::Semaphore terminate_requested_semaphore(0);
|
|
v8::base::Semaphore terminate_fired_semaphore(0);
|
|
|
|
class DebugBreakTriggerTerminate : public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(v8::Local<v8::Context> paused_context,
|
|
const std::vector<v8::debug::BreakpointId>&
|
|
inspector_break_points_hit) override {
|
|
if (terminate_already_fired_) return;
|
|
terminate_requested_semaphore.Signal();
|
|
// Wait for at most 2 seconds for the terminate request.
|
|
CHECK(
|
|
terminate_fired_semaphore.WaitFor(v8::base::TimeDelta::FromSeconds(2)));
|
|
terminate_already_fired_ = true;
|
|
}
|
|
|
|
private:
|
|
bool terminate_already_fired_ = false;
|
|
};
|
|
|
|
class TerminationThread : public v8::base::Thread {
|
|
public:
|
|
explicit TerminationThread(v8::Isolate* isolate)
|
|
: Thread(Options("terminator")), isolate_(isolate) {}
|
|
|
|
void Run() override {
|
|
terminate_requested_semaphore.Wait();
|
|
isolate_->TerminateExecution();
|
|
terminate_fired_semaphore.Signal();
|
|
}
|
|
|
|
private:
|
|
v8::Isolate* isolate_;
|
|
};
|
|
|
|
|
|
TEST(DebugBreakOffThreadTerminate) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
DebugBreakTriggerTerminate delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
TerminationThread terminator(isolate);
|
|
terminator.Start();
|
|
v8::TryCatch try_catch(env->GetIsolate());
|
|
env->GetIsolate()->RequestInterrupt(BreakRightNow, nullptr);
|
|
CompileRun("while (true);");
|
|
CHECK(try_catch.HasTerminated());
|
|
}
|
|
|
|
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) {}
|
|
|
|
void Run() override {
|
|
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>&) override {
|
|
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();
|
|
}
|
|
|
|
class DebugEventExpectNoException : public v8::debug::DebugDelegate {
|
|
public:
|
|
void ExceptionThrown(v8::Local<v8::Context> paused_context,
|
|
v8::Local<v8::Value> exception,
|
|
v8::Local<v8::Value> promise, bool is_uncaught,
|
|
v8::debug::ExceptionType) override {
|
|
CHECK(false);
|
|
}
|
|
};
|
|
|
|
static void TryCatchWrappedThrowCallback(
|
|
const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::TryCatch try_catch(args.GetIsolate());
|
|
CompileRun("throw 'rejection';");
|
|
CHECK(try_catch.HasCaught());
|
|
}
|
|
|
|
TEST(DebugPromiseInterceptedByTryCatch) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
DebugEventExpectNoException delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
v8::Local<v8::Context> context = env.local();
|
|
ChangeBreakOnException(false, true);
|
|
|
|
v8::Local<v8::FunctionTemplate> fun =
|
|
v8::FunctionTemplate::New(isolate, TryCatchWrappedThrowCallback);
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str("fun"),
|
|
fun->GetFunction(context).ToLocalChecked())
|
|
.FromJust());
|
|
|
|
CompileRun("var p = new Promise(function(res, rej) { fun(); res(); });");
|
|
CompileRun(
|
|
"var r;"
|
|
"p.then(function() { r = 'resolved'; },"
|
|
" function() { r = 'rejected'; });");
|
|
CHECK(CompileRun("r")->Equals(context, v8_str("resolved")).FromJust());
|
|
}
|
|
|
|
class NoInterruptsOnDebugEvent : public v8::debug::DebugDelegate {
|
|
public:
|
|
void ScriptCompiled(v8::Local<v8::debug::Script> script, bool is_live_edited,
|
|
bool has_compile_error) override {
|
|
++after_compile_handler_depth_;
|
|
// Do not allow nested AfterCompile events.
|
|
CHECK_LE(after_compile_handler_depth_, 1);
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
v8::Isolate::AllowJavascriptExecutionScope allow_script(isolate);
|
|
isolate->RequestInterrupt(&HandleInterrupt, this);
|
|
CompileRun("function foo() {}; foo();");
|
|
--after_compile_handler_depth_;
|
|
}
|
|
|
|
private:
|
|
static void HandleInterrupt(v8::Isolate* isolate, void* data) {
|
|
NoInterruptsOnDebugEvent* d = static_cast<NoInterruptsOnDebugEvent*>(data);
|
|
CHECK_EQ(0, d->after_compile_handler_depth_);
|
|
}
|
|
|
|
int after_compile_handler_depth_ = 0;
|
|
};
|
|
|
|
TEST(NoInterruptsInDebugListener) {
|
|
LocalContext env;
|
|
v8::HandleScope handle_scope(env->GetIsolate());
|
|
NoInterruptsOnDebugEvent delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
CompileRun("void(0);");
|
|
}
|
|
|
|
TEST(BreakLocationIterator) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
|
|
v8::HandleScope scope(isolate);
|
|
|
|
v8::Local<v8::Value> result = CompileRun(
|
|
"function f() {\n"
|
|
" debugger; \n"
|
|
" f(); \n"
|
|
" debugger; \n"
|
|
"} \n"
|
|
"f");
|
|
Handle<i::Object> function_obj = v8::Utils::OpenHandle(*result);
|
|
Handle<i::JSFunction> function = Handle<i::JSFunction>::cast(function_obj);
|
|
Handle<i::SharedFunctionInfo> shared(function->shared(), i_isolate);
|
|
|
|
EnableDebugger(isolate);
|
|
CHECK(i_isolate->debug()->EnsureBreakInfo(shared));
|
|
i_isolate->debug()->PrepareFunctionForDebugExecution(shared);
|
|
|
|
Handle<i::DebugInfo> debug_info(shared->GetDebugInfo(), i_isolate);
|
|
|
|
{
|
|
i::BreakIterator iterator(debug_info);
|
|
CHECK(iterator.GetBreakLocation().IsDebuggerStatement());
|
|
CHECK_EQ(17, iterator.GetBreakLocation().position());
|
|
iterator.Next();
|
|
CHECK(iterator.GetBreakLocation().IsDebugBreakSlot());
|
|
CHECK_EQ(32, iterator.GetBreakLocation().position());
|
|
iterator.Next();
|
|
CHECK(iterator.GetBreakLocation().IsCall());
|
|
CHECK_EQ(32, iterator.GetBreakLocation().position());
|
|
iterator.Next();
|
|
CHECK(iterator.GetBreakLocation().IsDebuggerStatement());
|
|
CHECK_EQ(47, iterator.GetBreakLocation().position());
|
|
iterator.Next();
|
|
CHECK(iterator.GetBreakLocation().IsReturn());
|
|
CHECK_EQ(60, iterator.GetBreakLocation().position());
|
|
iterator.Next();
|
|
CHECK(iterator.Done());
|
|
}
|
|
|
|
DisableDebugger(isolate);
|
|
}
|
|
|
|
class DebugStepOverFunctionWithCaughtExceptionListener
|
|
: public v8::debug::DebugDelegate {
|
|
public:
|
|
void BreakProgramRequested(v8::Local<v8::Context> paused_context,
|
|
const std::vector<v8::debug::BreakpointId>&
|
|
inspector_break_points_hit) override {
|
|
++break_point_hit_count;
|
|
if (break_point_hit_count >= 3) return;
|
|
PrepareStep(StepNext);
|
|
}
|
|
int break_point_hit_count = 0;
|
|
};
|
|
|
|
TEST(DebugStepOverFunctionWithCaughtException) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
DebugStepOverFunctionWithCaughtExceptionListener delegate;
|
|
v8::debug::SetDebugDelegate(isolate, &delegate);
|
|
|
|
CompileRun(
|
|
"function foo() {\n"
|
|
" try { throw new Error(); } catch (e) {}\n"
|
|
"}\n"
|
|
"debugger;\n"
|
|
"foo();\n"
|
|
"foo();\n");
|
|
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
CHECK_EQ(3, delegate.break_point_hit_count);
|
|
}
|
|
|
|
bool near_heap_limit_callback_called = false;
|
|
size_t NearHeapLimitCallback(void* data, size_t current_heap_limit,
|
|
size_t initial_heap_limit) {
|
|
near_heap_limit_callback_called = true;
|
|
return initial_heap_limit + 10u * i::MB;
|
|
}
|
|
|
|
UNINITIALIZED_TEST(DebugSetOutOfMemoryListener) {
|
|
v8::Isolate::CreateParams create_params;
|
|
create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
|
|
create_params.constraints.set_max_old_space_size(10);
|
|
v8::Isolate* isolate = v8::Isolate::New(create_params);
|
|
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
|
|
{
|
|
v8::Isolate::Scope i_scope(isolate);
|
|
v8::HandleScope scope(isolate);
|
|
LocalContext context(isolate);
|
|
isolate->AddNearHeapLimitCallback(NearHeapLimitCallback, nullptr);
|
|
CHECK(!near_heap_limit_callback_called);
|
|
// The following allocation fails unless the out-of-memory callback
|
|
// increases the heap limit.
|
|
int length = 10 * i::MB / i::kTaggedSize;
|
|
i_isolate->factory()->NewFixedArray(length, i::AllocationType::kOld);
|
|
CHECK(near_heap_limit_callback_called);
|
|
isolate->RemoveNearHeapLimitCallback(NearHeapLimitCallback, 0);
|
|
}
|
|
isolate->Dispose();
|
|
}
|
|
|
|
TEST(DebugCoverage) {
|
|
i::FLAG_always_opt = false;
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
v8::debug::Coverage::SelectMode(isolate,
|
|
v8::debug::CoverageMode::kPreciseCount);
|
|
v8::Local<v8::String> source = v8_str(
|
|
"function f() {\n"
|
|
"}\n"
|
|
"f();\n"
|
|
"f();");
|
|
CompileRun(source);
|
|
v8::debug::Coverage coverage = v8::debug::Coverage::CollectPrecise(isolate);
|
|
CHECK_EQ(1u, coverage.ScriptCount());
|
|
v8::debug::Coverage::ScriptData script_data = coverage.GetScriptData(0);
|
|
v8::Local<v8::debug::Script> script = script_data.GetScript();
|
|
CHECK(script->Source()
|
|
.ToLocalChecked()
|
|
->Equals(env.local(), source)
|
|
.FromMaybe(false));
|
|
|
|
CHECK_EQ(2u, script_data.FunctionCount());
|
|
v8::debug::Coverage::FunctionData function_data =
|
|
script_data.GetFunctionData(0);
|
|
v8::debug::Location start =
|
|
script->GetSourceLocation(function_data.StartOffset());
|
|
v8::debug::Location end =
|
|
script->GetSourceLocation(function_data.EndOffset());
|
|
CHECK_EQ(0, start.GetLineNumber());
|
|
CHECK_EQ(0, start.GetColumnNumber());
|
|
CHECK_EQ(3, end.GetLineNumber());
|
|
CHECK_EQ(4, end.GetColumnNumber());
|
|
CHECK_EQ(1, function_data.Count());
|
|
|
|
function_data = script_data.GetFunctionData(1);
|
|
start = script->GetSourceLocation(function_data.StartOffset());
|
|
end = script->GetSourceLocation(function_data.EndOffset());
|
|
CHECK_EQ(0, start.GetLineNumber());
|
|
CHECK_EQ(0, start.GetColumnNumber());
|
|
CHECK_EQ(1, end.GetLineNumber());
|
|
CHECK_EQ(1, end.GetColumnNumber());
|
|
CHECK_EQ(2, function_data.Count());
|
|
}
|
|
|
|
namespace {
|
|
v8::debug::Coverage::ScriptData GetScriptDataAndDeleteCoverage(
|
|
v8::Isolate* isolate) {
|
|
v8::debug::Coverage coverage = v8::debug::Coverage::CollectPrecise(isolate);
|
|
CHECK_EQ(1u, coverage.ScriptCount());
|
|
return coverage.GetScriptData(0);
|
|
}
|
|
} // namespace
|
|
|
|
TEST(DebugCoverageWithCoverageOutOfScope) {
|
|
i::FLAG_always_opt = false;
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
v8::debug::Coverage::SelectMode(isolate,
|
|
v8::debug::CoverageMode::kPreciseCount);
|
|
v8::Local<v8::String> source = v8_str(
|
|
"function f() {\n"
|
|
"}\n"
|
|
"f();\n"
|
|
"f();");
|
|
CompileRun(source);
|
|
v8::debug::Coverage::ScriptData script_data =
|
|
GetScriptDataAndDeleteCoverage(isolate);
|
|
v8::Local<v8::debug::Script> script = script_data.GetScript();
|
|
CHECK(script->Source()
|
|
.ToLocalChecked()
|
|
->Equals(env.local(), source)
|
|
.FromMaybe(false));
|
|
|
|
CHECK_EQ(2u, script_data.FunctionCount());
|
|
v8::debug::Coverage::FunctionData function_data =
|
|
script_data.GetFunctionData(0);
|
|
|
|
CHECK_EQ(0, function_data.StartOffset());
|
|
CHECK_EQ(26, function_data.EndOffset());
|
|
|
|
v8::debug::Location start =
|
|
script->GetSourceLocation(function_data.StartOffset());
|
|
v8::debug::Location end =
|
|
script->GetSourceLocation(function_data.EndOffset());
|
|
CHECK_EQ(0, start.GetLineNumber());
|
|
CHECK_EQ(0, start.GetColumnNumber());
|
|
CHECK_EQ(3, end.GetLineNumber());
|
|
CHECK_EQ(4, end.GetColumnNumber());
|
|
CHECK_EQ(1, function_data.Count());
|
|
|
|
function_data = script_data.GetFunctionData(1);
|
|
start = script->GetSourceLocation(function_data.StartOffset());
|
|
end = script->GetSourceLocation(function_data.EndOffset());
|
|
|
|
CHECK_EQ(0, function_data.StartOffset());
|
|
CHECK_EQ(16, function_data.EndOffset());
|
|
|
|
CHECK_EQ(0, start.GetLineNumber());
|
|
CHECK_EQ(0, start.GetColumnNumber());
|
|
CHECK_EQ(1, end.GetLineNumber());
|
|
CHECK_EQ(1, end.GetColumnNumber());
|
|
CHECK_EQ(2, function_data.Count());
|
|
}
|
|
|
|
namespace {
|
|
v8::debug::Coverage::FunctionData GetFunctionDataAndDeleteCoverage(
|
|
v8::Isolate* isolate) {
|
|
v8::debug::Coverage coverage = v8::debug::Coverage::CollectPrecise(isolate);
|
|
CHECK_EQ(1u, coverage.ScriptCount());
|
|
|
|
v8::debug::Coverage::ScriptData script_data = coverage.GetScriptData(0);
|
|
|
|
CHECK_EQ(2u, script_data.FunctionCount());
|
|
v8::debug::Coverage::FunctionData function_data =
|
|
script_data.GetFunctionData(0);
|
|
CHECK_EQ(1, function_data.Count());
|
|
CHECK_EQ(0, function_data.StartOffset());
|
|
CHECK_EQ(26, function_data.EndOffset());
|
|
return function_data;
|
|
}
|
|
} // namespace
|
|
|
|
TEST(DebugCoverageWithScriptDataOutOfScope) {
|
|
i::FLAG_always_opt = false;
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
v8::debug::Coverage::SelectMode(isolate,
|
|
v8::debug::CoverageMode::kPreciseCount);
|
|
v8::Local<v8::String> source = v8_str(
|
|
"function f() {\n"
|
|
"}\n"
|
|
"f();\n"
|
|
"f();");
|
|
CompileRun(source);
|
|
|
|
v8::debug::Coverage::FunctionData function_data =
|
|
GetFunctionDataAndDeleteCoverage(isolate);
|
|
CHECK_EQ(1, function_data.Count());
|
|
CHECK_EQ(0, function_data.StartOffset());
|
|
CHECK_EQ(26, function_data.EndOffset());
|
|
}
|
|
|
|
TEST(BuiltinsExceptionPrediction) {
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
i::Isolate* iisolate = CcTest::i_isolate();
|
|
v8::HandleScope handle_scope(isolate);
|
|
v8::Context::New(isolate);
|
|
|
|
i::Builtins* builtins = iisolate->builtins();
|
|
bool fail = false;
|
|
for (int i = 0; i < i::Builtins::builtin_count; i++) {
|
|
i::Code builtin = builtins->builtin(i);
|
|
if (builtin->kind() != i::Code::BUILTIN) continue;
|
|
auto prediction = builtin->GetBuiltinCatchPrediction();
|
|
USE(prediction);
|
|
}
|
|
CHECK(!fail);
|
|
}
|
|
|
|
TEST(DebugGetPossibleBreakpointsReturnLocations) {
|
|
LocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
v8::Local<v8::String> source = v8_str(
|
|
"function fib(x) {\n"
|
|
" if (x < 0) return;\n"
|
|
" if (x === 0) return 1;\n"
|
|
" if (x === 1) return fib(0);\n"
|
|
" return x > 2 ? fib(x - 1) + fib(x - 2) : fib(1) + fib(0);\n"
|
|
"}");
|
|
CompileRun(source);
|
|
v8::PersistentValueVector<v8::debug::Script> scripts(isolate);
|
|
v8::debug::GetLoadedScripts(isolate, scripts);
|
|
CHECK_EQ(scripts.Size(), 1);
|
|
std::vector<v8::debug::BreakLocation> locations;
|
|
CHECK(scripts.Get(0)->GetPossibleBreakpoints(
|
|
v8::debug::Location(0, 17), v8::debug::Location(), true, &locations));
|
|
int returns_count = 0;
|
|
for (size_t i = 0; i < locations.size(); ++i) {
|
|
if (locations[i].type() == v8::debug::kReturnBreakLocation) {
|
|
++returns_count;
|
|
}
|
|
}
|
|
// With Ignition we generate one return location per return statement,
|
|
// each has line = 5, column = 0 as statement position.
|
|
CHECK_EQ(returns_count, 4);
|
|
}
|
|
|
|
TEST(DebugEvaluateNoSideEffect) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
EnableDebugger(env->GetIsolate());
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
std::vector<i::Handle<i::JSFunction>> all_functions;
|
|
{
|
|
i::HeapIterator iterator(isolate->heap());
|
|
for (i::HeapObject obj = iterator.next(); !obj.is_null();
|
|
obj = iterator.next()) {
|
|
if (!obj->IsJSFunction()) continue;
|
|
i::JSFunction fun = i::JSFunction::cast(obj);
|
|
all_functions.emplace_back(fun, isolate);
|
|
}
|
|
}
|
|
|
|
// Perform side effect check on all built-in functions. The side effect check
|
|
// itself contains additional sanity checks.
|
|
for (i::Handle<i::JSFunction> fun : all_functions) {
|
|
bool failed = false;
|
|
isolate->debug()->StartSideEffectCheckMode();
|
|
failed = !isolate->debug()->PerformSideEffectCheck(
|
|
fun, v8::Utils::OpenHandle(*env->Global()));
|
|
isolate->debug()->StopSideEffectCheckMode();
|
|
if (failed) isolate->clear_pending_exception();
|
|
}
|
|
DisableDebugger(env->GetIsolate());
|
|
}
|
|
|
|
namespace {
|
|
i::MaybeHandle<i::Script> FindScript(
|
|
i::Isolate* isolate, const std::vector<i::Handle<i::Script>>& scripts,
|
|
const char* name) {
|
|
Handle<i::String> i_name =
|
|
isolate->factory()->NewStringFromAsciiChecked(name);
|
|
for (const auto& script : scripts) {
|
|
if (!script->name()->IsString()) continue;
|
|
if (i_name->Equals(i::String::cast(script->name()))) return script;
|
|
}
|
|
return i::MaybeHandle<i::Script>();
|
|
}
|
|
} // anonymous namespace
|
|
|
|
UNINITIALIZED_TEST(LoadedAtStartupScripts) {
|
|
i::FLAG_expose_gc = true;
|
|
|
|
v8::Isolate::CreateParams create_params;
|
|
create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
|
|
v8::Isolate* isolate = v8::Isolate::New(create_params);
|
|
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
|
|
{
|
|
v8::Isolate::Scope i_scope(isolate);
|
|
v8::HandleScope scope(isolate);
|
|
LocalContext context(isolate);
|
|
|
|
std::vector<i::Handle<i::Script>> scripts;
|
|
CompileWithOrigin(v8_str("function foo(){}"), v8_str("normal.js"),
|
|
v8_bool(false));
|
|
std::unordered_map<int, int> count_by_type;
|
|
{
|
|
i::DisallowHeapAllocation no_gc;
|
|
i::Script::Iterator iterator(i_isolate);
|
|
for (i::Script script = iterator.Next(); !script.is_null();
|
|
script = iterator.Next()) {
|
|
if (script->type() == i::Script::TYPE_NATIVE &&
|
|
script->name()->IsUndefined(i_isolate)) {
|
|
continue;
|
|
}
|
|
++count_by_type[script->type()];
|
|
scripts.emplace_back(script, i_isolate);
|
|
}
|
|
}
|
|
CHECK_EQ(count_by_type[i::Script::TYPE_NATIVE], 0);
|
|
CHECK_EQ(count_by_type[i::Script::TYPE_EXTENSION], 2);
|
|
CHECK_EQ(count_by_type[i::Script::TYPE_NORMAL], 1);
|
|
CHECK_EQ(count_by_type[i::Script::TYPE_WASM], 0);
|
|
CHECK_EQ(count_by_type[i::Script::TYPE_INSPECTOR], 0);
|
|
|
|
i::Handle<i::Script> gc_script =
|
|
FindScript(i_isolate, scripts, "v8/gc").ToHandleChecked();
|
|
CHECK_EQ(gc_script->type(), i::Script::TYPE_EXTENSION);
|
|
|
|
i::Handle<i::Script> normal_script =
|
|
FindScript(i_isolate, scripts, "normal.js").ToHandleChecked();
|
|
CHECK_EQ(normal_script->type(), i::Script::TYPE_NORMAL);
|
|
}
|
|
isolate->Dispose();
|
|
}
|
|
|
|
TEST(SourceInfo) {
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
const char* source =
|
|
"//\n"
|
|
"function a() { b(); };\n"
|
|
"function b() {\n"
|
|
" c(true);\n"
|
|
"};\n"
|
|
" function c(x) {\n"
|
|
" if (x) {\n"
|
|
" return 1;\n"
|
|
" } else {\n"
|
|
" return 1;\n"
|
|
" }\n"
|
|
" };\n"
|
|
"function d(x) {\n"
|
|
" x = 1 ;\n"
|
|
" x = 2 ;\n"
|
|
" x = 3 ;\n"
|
|
" x = 4 ;\n"
|
|
" x = 5 ;\n"
|
|
" x = 6 ;\n"
|
|
" x = 7 ;\n"
|
|
" x = 8 ;\n"
|
|
" x = 9 ;\n"
|
|
" x = 10;\n"
|
|
" x = 11;\n"
|
|
" x = 12;\n"
|
|
" x = 13;\n"
|
|
" x = 14;\n"
|
|
" x = 15;\n"
|
|
"}\n";
|
|
v8::Local<v8::Script> v8_script =
|
|
v8::Script::Compile(env.local(), v8_str(source)).ToLocalChecked();
|
|
i::Handle<i::Script> i_script(
|
|
i::Script::cast(v8::Utils::OpenHandle(*v8_script)->shared()->script()),
|
|
CcTest::i_isolate());
|
|
v8::Local<v8::debug::Script> script =
|
|
v8::ToApiHandle<v8::debug::Script>(i_script);
|
|
|
|
// Test that when running through source positions the position, line and
|
|
// column progresses as expected.
|
|
v8::debug::Location prev_location = script->GetSourceLocation(0);
|
|
CHECK_EQ(prev_location.GetLineNumber(), 0);
|
|
CHECK_EQ(prev_location.GetColumnNumber(), 0);
|
|
for (int offset = 1; offset < 100; ++offset) {
|
|
v8::debug::Location location = script->GetSourceLocation(offset);
|
|
if (prev_location.GetLineNumber() == location.GetLineNumber()) {
|
|
CHECK_EQ(location.GetColumnNumber(), prev_location.GetColumnNumber() + 1);
|
|
} else {
|
|
CHECK_EQ(location.GetLineNumber(), prev_location.GetLineNumber() + 1);
|
|
CHECK_EQ(location.GetColumnNumber(), 0);
|
|
}
|
|
prev_location = location;
|
|
}
|
|
|
|
// Every line of d() is the same length. Verify we can loop through all
|
|
// positions and find the right line # for each.
|
|
// The position of the first line of d(), i.e. "x = 1 ;".
|
|
const int start_line_d = 13;
|
|
const int start_code_d =
|
|
static_cast<int>(strstr(source, " x = 1 ;") - source);
|
|
const int num_lines_d = 15;
|
|
const int line_length_d = 10;
|
|
int p = start_code_d;
|
|
for (int line = 0; line < num_lines_d; ++line) {
|
|
for (int column = 0; column < line_length_d; ++column) {
|
|
v8::debug::Location location = script->GetSourceLocation(p);
|
|
CHECK_EQ(location.GetLineNumber(), start_line_d + line);
|
|
CHECK_EQ(location.GetColumnNumber(), column);
|
|
++p;
|
|
}
|
|
}
|
|
|
|
// Test first positon.
|
|
CHECK_EQ(script->GetSourceLocation(0).GetLineNumber(), 0);
|
|
CHECK_EQ(script->GetSourceLocation(0).GetColumnNumber(), 0);
|
|
|
|
// Test second positon.
|
|
CHECK_EQ(script->GetSourceLocation(1).GetLineNumber(), 0);
|
|
CHECK_EQ(script->GetSourceLocation(1).GetColumnNumber(), 1);
|
|
|
|
// Test first positin in function a().
|
|
const int start_a =
|
|
static_cast<int>(strstr(source, "function a") - source) + 10;
|
|
CHECK_EQ(script->GetSourceLocation(start_a).GetLineNumber(), 1);
|
|
CHECK_EQ(script->GetSourceLocation(start_a).GetColumnNumber(), 10);
|
|
|
|
// Test first positin in function b().
|
|
const int start_b =
|
|
static_cast<int>(strstr(source, "function b") - source) + 13;
|
|
CHECK_EQ(script->GetSourceLocation(start_b).GetLineNumber(), 2);
|
|
CHECK_EQ(script->GetSourceLocation(start_b).GetColumnNumber(), 13);
|
|
|
|
// Test first positin in function c().
|
|
const int start_c =
|
|
static_cast<int>(strstr(source, "function c") - source) + 10;
|
|
CHECK_EQ(script->GetSourceLocation(start_c).GetLineNumber(), 5);
|
|
CHECK_EQ(script->GetSourceLocation(start_c).GetColumnNumber(), 12);
|
|
|
|
// Test first positin in function d().
|
|
const int start_d =
|
|
static_cast<int>(strstr(source, "function d") - source) + 10;
|
|
CHECK_EQ(script->GetSourceLocation(start_d).GetLineNumber(), 12);
|
|
CHECK_EQ(script->GetSourceLocation(start_d).GetColumnNumber(), 10);
|
|
|
|
// Test offsets.
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(1, 10)), start_a);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(2, 13)), start_b);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(3, 0)), start_b + 5);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(3, 2)), start_b + 7);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(4, 0)), start_b + 16);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(5, 12)), start_c);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(6, 0)), start_c + 6);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(7, 0)), start_c + 19);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(8, 0)), start_c + 35);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(9, 0)), start_c + 48);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(10, 0)), start_c + 64);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(11, 0)), start_c + 70);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(12, 10)), start_d);
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(13, 0)), start_d + 6);
|
|
for (int i = 1; i <= num_lines_d; ++i) {
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(start_line_d + i, 0)),
|
|
6 + (i * line_length_d) + start_d);
|
|
}
|
|
CHECK_EQ(script->GetSourceOffset(v8::debug::Location(start_line_d + 17, 0)),
|
|
start_d + 158);
|
|
|
|
// Make sure invalid inputs work properly.
|
|
const int last_position = static_cast<int>(strlen(source)) - 1;
|
|
CHECK_EQ(script->GetSourceLocation(-1).GetLineNumber(), 0);
|
|
CHECK_EQ(script->GetSourceLocation(last_position + 2).GetLineNumber(),
|
|
i::kNoSourcePosition);
|
|
|
|
// Test last position.
|
|
CHECK_EQ(script->GetSourceLocation(last_position).GetLineNumber(), 28);
|
|
CHECK_EQ(script->GetSourceLocation(last_position).GetColumnNumber(), 1);
|
|
CHECK_EQ(script->GetSourceLocation(last_position + 1).GetLineNumber(), 29);
|
|
CHECK_EQ(script->GetSourceLocation(last_position + 1).GetColumnNumber(), 0);
|
|
}
|
|
|
|
namespace {
|
|
class SetBreakpointOnScriptCompiled : public v8::debug::DebugDelegate {
|
|
public:
|
|
void ScriptCompiled(v8::Local<v8::debug::Script> script, bool is_live_edited,
|
|
bool has_compile_error) override {
|
|
v8::Local<v8::String> name;
|
|
if (!script->SourceURL().ToLocal(&name)) return;
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
if (!name->Equals(context, v8_str("test")).FromJust()) return;
|
|
CHECK(!has_compile_error);
|
|
v8::debug::Location loc(1, 2);
|
|
CHECK(script->SetBreakpoint(v8_str(""), &loc, &id_));
|
|
CHECK_EQ(loc.GetLineNumber(), 1);
|
|
CHECK_EQ(loc.GetColumnNumber(), 10);
|
|
}
|
|
|
|
void BreakProgramRequested(v8::Local<v8::Context> paused_context,
|
|
const std::vector<v8::debug::BreakpointId>&
|
|
inspector_break_points_hit) override {
|
|
++break_count_;
|
|
CHECK_EQ(inspector_break_points_hit[0], id_);
|
|
}
|
|
|
|
int break_count() const { return break_count_; }
|
|
|
|
private:
|
|
int break_count_ = 0;
|
|
v8::debug::BreakpointId id_;
|
|
};
|
|
} // anonymous namespace
|
|
|
|
TEST(Regress517592) {
|
|
LocalContext env;
|
|
v8::HandleScope handle_scope(env->GetIsolate());
|
|
SetBreakpointOnScriptCompiled delegate;
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), &delegate);
|
|
CompileRun(
|
|
v8_str("eval('var foo = function foo() {\\n' +\n"
|
|
"' var a = 1;\\n' +\n"
|
|
"'}\\n' +\n"
|
|
"'//@ sourceURL=test')"));
|
|
CHECK_EQ(delegate.break_count(), 0);
|
|
CompileRun(v8_str("foo()"));
|
|
CHECK_EQ(delegate.break_count(), 1);
|
|
v8::debug::SetDebugDelegate(env->GetIsolate(), nullptr);
|
|
}
|
|
|
|
TEST(GetPrivateFields) {
|
|
LocalContext env;
|
|
v8::Isolate* v8_isolate = CcTest::isolate();
|
|
v8::internal::Isolate* isolate = CcTest::i_isolate();
|
|
v8::HandleScope scope(v8_isolate);
|
|
v8::Local<v8::Context> context = env.local();
|
|
v8::Local<v8::String> source = v8_str(
|
|
"var X = class {\n"
|
|
" #foo = 1;\n"
|
|
" #bar = function() {};\n"
|
|
"}\n"
|
|
"var x = new X()");
|
|
CompileRun(source);
|
|
v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "x"))
|
|
.ToLocalChecked());
|
|
v8::Local<v8::Array> private_names =
|
|
v8::debug::GetPrivateFields(context, object).ToLocalChecked();
|
|
|
|
for (int i = 0; i < 4; i = i + 2) {
|
|
Handle<v8::internal::JSReceiver> private_name =
|
|
v8::Utils::OpenHandle(*private_names->Get(context, i)
|
|
.ToLocalChecked()
|
|
->ToObject(context)
|
|
.ToLocalChecked());
|
|
Handle<v8::internal::JSValue> private_value =
|
|
Handle<v8::internal::JSValue>::cast(private_name);
|
|
Handle<v8::internal::Symbol> priv_symbol(
|
|
v8::internal::Symbol::cast(private_value->value()), isolate);
|
|
CHECK(priv_symbol->is_private_name());
|
|
}
|
|
|
|
source = v8_str(
|
|
"var Y = class {\n"
|
|
" #baz = 2;\n"
|
|
"}\n"
|
|
"var X = class extends Y{\n"
|
|
" #foo = 1;\n"
|
|
" #bar = function() {};\n"
|
|
"}\n"
|
|
"var x = new X()");
|
|
CompileRun(source);
|
|
object = v8::Local<v8::Object>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "x"))
|
|
.ToLocalChecked());
|
|
private_names = v8::debug::GetPrivateFields(context, object).ToLocalChecked();
|
|
|
|
for (int i = 0; i < 6; i = i + 2) {
|
|
Handle<v8::internal::JSReceiver> private_name =
|
|
v8::Utils::OpenHandle(*private_names->Get(context, i)
|
|
.ToLocalChecked()
|
|
->ToObject(context)
|
|
.ToLocalChecked());
|
|
Handle<v8::internal::JSValue> private_value =
|
|
Handle<v8::internal::JSValue>::cast(private_name);
|
|
Handle<v8::internal::Symbol> priv_symbol(
|
|
v8::internal::Symbol::cast(private_value->value()), isolate);
|
|
CHECK(priv_symbol->is_private_name());
|
|
}
|
|
|
|
source = v8_str(
|
|
"var Y = class {\n"
|
|
" constructor() {"
|
|
" return new Proxy({}, {});"
|
|
" }"
|
|
"}\n"
|
|
"var X = class extends Y{\n"
|
|
" #foo = 1;\n"
|
|
" #bar = function() {};\n"
|
|
"}\n"
|
|
"var x = new X()");
|
|
CompileRun(source);
|
|
object = v8::Local<v8::Object>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "x"))
|
|
.ToLocalChecked());
|
|
private_names = v8::debug::GetPrivateFields(context, object).ToLocalChecked();
|
|
|
|
for (int i = 0; i < 4; i = i + 2) {
|
|
Handle<v8::internal::JSReceiver> private_name =
|
|
v8::Utils::OpenHandle(*private_names->Get(context, i)
|
|
.ToLocalChecked()
|
|
->ToObject(context)
|
|
.ToLocalChecked());
|
|
Handle<v8::internal::JSValue> private_value =
|
|
Handle<v8::internal::JSValue>::cast(private_name);
|
|
Handle<v8::internal::Symbol> priv_symbol(
|
|
v8::internal::Symbol::cast(private_value->value()), isolate);
|
|
CHECK(priv_symbol->is_private_name());
|
|
}
|
|
}
|