dd5c7fe73d
This CL ads a StartPosition and EndPosition accessors on SFI and ScopeInfo to facilitate future refactoring. In a future CL the start and end position are no longer stored directly on SFIs. This CL will temporarily increase memory since the position info is duplicated on the SFI and the ScopeInfo. Drive-by-fix: Clean up some constants in ScopeInfo Bug: v8:7066 Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng Change-Id: I1a8c5dd4e2156c007e04d92e72e478b915516e0d Reviewed-on: https://chromium-review.googlesource.com/955629 Reviewed-by: Jakob Gruber <jgruber@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Reviewed-by: Marja Hölttä <marja@chromium.org> Commit-Queue: Camillo Bruni <cbruni@chromium.org> Cr-Commit-Position: refs/heads/master@{#51987}
6434 lines
222 KiB
C++
6434 lines
222 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 <set>
|
|
|
|
#include "src/v8.h"
|
|
|
|
#include "src/api.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/snapshot.h"
|
|
#include "src/utils.h"
|
|
#include "test/cctest/cctest.h"
|
|
|
|
using ::v8::internal::EmbeddedVector;
|
|
using ::v8::internal::Object;
|
|
using ::v8::internal::Handle;
|
|
using ::v8::internal::Heap;
|
|
using ::v8::internal::JSGlobalProxy;
|
|
using ::v8::internal::Code;
|
|
using ::v8::internal::Debug;
|
|
using ::v8::internal::StackFrame;
|
|
using ::v8::internal::StepAction;
|
|
using ::v8::internal::StepIn; // From StepAction enum
|
|
using ::v8::internal::StepNext; // From StepAction enum
|
|
using ::v8::internal::StepOut; // From StepAction enum
|
|
using ::v8::internal::Vector;
|
|
using ::v8::internal::StrLength;
|
|
|
|
// Size of temp buffer for formatting small strings.
|
|
#define SMALL_STRING_BUFFER_SIZE 80
|
|
|
|
// --- H e l p e r C l a s s e s
|
|
|
|
|
|
// Helper class for creating a V8 enviromnent for running tests
|
|
class DebugLocalContext {
|
|
public:
|
|
inline DebugLocalContext(
|
|
v8::Isolate* isolate, v8::ExtensionConfiguration* extensions = 0,
|
|
v8::Local<v8::ObjectTemplate> global_template =
|
|
v8::Local<v8::ObjectTemplate>(),
|
|
v8::Local<v8::Value> global_object = v8::Local<v8::Value>())
|
|
: scope_(isolate),
|
|
context_(v8::Context::New(isolate, extensions, global_template,
|
|
global_object)) {
|
|
context_->Enter();
|
|
}
|
|
inline DebugLocalContext(
|
|
v8::ExtensionConfiguration* extensions = 0,
|
|
v8::Local<v8::ObjectTemplate> global_template =
|
|
v8::Local<v8::ObjectTemplate>(),
|
|
v8::Local<v8::Value> global_object = v8::Local<v8::Value>())
|
|
: scope_(CcTest::isolate()),
|
|
context_(v8::Context::New(CcTest::isolate(), extensions,
|
|
global_template, global_object)) {
|
|
context_->Enter();
|
|
}
|
|
inline ~DebugLocalContext() {
|
|
context_->Exit();
|
|
}
|
|
inline v8::Local<v8::Context> context() { return context_; }
|
|
inline v8::Context* operator->() { return *context_; }
|
|
inline v8::Context* operator*() { return *context_; }
|
|
inline v8::Isolate* GetIsolate() { return context_->GetIsolate(); }
|
|
inline bool IsReady() { return !context_.IsEmpty(); }
|
|
void ExposeDebug() {
|
|
v8::internal::Isolate* isolate =
|
|
reinterpret_cast<v8::internal::Isolate*>(context_->GetIsolate());
|
|
v8::internal::Factory* factory = isolate->factory();
|
|
// Expose the debug context global object in the global object for testing.
|
|
CHECK(isolate->debug()->Load());
|
|
Handle<v8::internal::Context> debug_context =
|
|
isolate->debug()->debug_context();
|
|
debug_context->set_security_token(
|
|
v8::Utils::OpenHandle(*context_)->security_token());
|
|
|
|
Handle<JSGlobalProxy> global(Handle<JSGlobalProxy>::cast(
|
|
v8::Utils::OpenHandle(*context_->Global())));
|
|
Handle<v8::internal::String> debug_string =
|
|
factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("debug"));
|
|
v8::internal::JSObject::SetOwnPropertyIgnoreAttributes(
|
|
global, debug_string, handle(debug_context->global_proxy()),
|
|
v8::internal::DONT_ENUM)
|
|
.Check();
|
|
}
|
|
|
|
private:
|
|
v8::HandleScope scope_;
|
|
v8::Local<v8::Context> context_;
|
|
};
|
|
|
|
|
|
// --- 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(DebugLocalContext* env,
|
|
const char* source,
|
|
const char* function_name) {
|
|
return CompileFunction(env->GetIsolate(), source, function_name);
|
|
}
|
|
|
|
static void SetDebugEventListener(
|
|
v8::Isolate* isolate, v8::Debug::EventCallback that,
|
|
v8::Local<v8::Value> data = v8::Local<v8::Value>()) {
|
|
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
|
|
i::HandleScope scope(i_isolate);
|
|
if (that == nullptr) {
|
|
i_isolate->debug()->SetDebugDelegate(nullptr, false);
|
|
} else {
|
|
i::Handle<i::Object> i_data = i_isolate->factory()->undefined_value();
|
|
if (!data.IsEmpty()) i_data = v8::Utils::OpenHandle(*data);
|
|
i::NativeDebugDelegate* delegate =
|
|
new i::NativeDebugDelegate(i_isolate, that, i_data);
|
|
i_isolate->debug()->SetDebugDelegate(delegate, true);
|
|
}
|
|
}
|
|
|
|
// 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());
|
|
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(function, 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);
|
|
}
|
|
|
|
|
|
// Change break on exception using the global Debug object.
|
|
static void ChangeBreakOnExceptionFromJS(v8::Isolate* isolate, bool caught,
|
|
bool uncaught) {
|
|
if (caught) {
|
|
CompileRunChecked(isolate, "debug.Debug.setBreakOnException()");
|
|
} else {
|
|
CompileRunChecked(isolate, "debug.Debug.clearBreakOnException()");
|
|
}
|
|
if (uncaught) {
|
|
CompileRunChecked(isolate, "debug.Debug.setBreakOnUncaughtException()");
|
|
} else {
|
|
CompileRunChecked(isolate, "debug.Debug.clearBreakOnUncaughtException()");
|
|
}
|
|
}
|
|
|
|
// Change break on exception using the native API call.
|
|
static void ChangeBreakOnExceptionFromAPI(
|
|
v8::Isolate* isolate, v8::debug::ExceptionBreakState state) {
|
|
v8::debug::ChangeBreakOnException(isolate, state);
|
|
}
|
|
|
|
// Prepare to step to next break location.
|
|
static void PrepareStep(StepAction step_action) {
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
debug->PrepareStep(step_action);
|
|
}
|
|
|
|
|
|
static void ClearStepping() { CcTest::i_isolate()->debug()->ClearStepping(); }
|
|
|
|
|
|
// 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_context().is_null());
|
|
CHECK(!CcTest::i_isolate()->debug()->debug_info_list_);
|
|
|
|
// Collect garbage to ensure weak handles are cleared.
|
|
CcTest::CollectAllGarbage();
|
|
CcTest::CollectAllGarbage(Heap::kMakeHeapIterableMask);
|
|
|
|
// Iterate the heap and check that there are no debugger related objects left.
|
|
HeapIterator iterator(CcTest::heap());
|
|
for (HeapObject* obj = iterator.next(); obj != nullptr;
|
|
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.
|
|
// ---
|
|
|
|
|
|
// Source for the JavaScript function which picks out the function
|
|
// name of a frame.
|
|
const char* frame_function_name_source =
|
|
"function frame_function_name(exec_state, frame_number) {"
|
|
" return exec_state.frame(frame_number).func().name();"
|
|
"}";
|
|
v8::Local<v8::Function> frame_function_name;
|
|
|
|
|
|
// Source for the JavaScript function which pick out the name of the
|
|
// first argument of a frame.
|
|
const char* frame_argument_name_source =
|
|
"function frame_argument_name(exec_state, frame_number) {"
|
|
" return exec_state.frame(frame_number).argumentName(0);"
|
|
"}";
|
|
v8::Local<v8::Function> frame_argument_name;
|
|
|
|
|
|
// Source for the JavaScript function which pick out the value of the
|
|
// first argument of a frame.
|
|
const char* frame_argument_value_source =
|
|
"function frame_argument_value(exec_state, frame_number) {"
|
|
" return exec_state.frame(frame_number).argumentValue(0).value_;"
|
|
"}";
|
|
v8::Local<v8::Function> frame_argument_value;
|
|
|
|
|
|
// Source for the JavaScript function which pick out the name of the
|
|
// first argument of a frame.
|
|
const char* frame_local_name_source =
|
|
"function frame_local_name(exec_state, frame_number) {"
|
|
" return exec_state.frame(frame_number).localName(0);"
|
|
"}";
|
|
v8::Local<v8::Function> frame_local_name;
|
|
|
|
|
|
// Source for the JavaScript function which pick out the value of the
|
|
// first argument of a frame.
|
|
const char* frame_local_value_source =
|
|
"function frame_local_value(exec_state, frame_number) {"
|
|
" return exec_state.frame(frame_number).localValue(0).value_;"
|
|
"}";
|
|
v8::Local<v8::Function> frame_local_value;
|
|
|
|
|
|
// Source for the JavaScript function which picks out the source line for the
|
|
// top frame.
|
|
const char* frame_source_line_source =
|
|
"function frame_source_line(exec_state) {"
|
|
" return exec_state.frame(0).sourceLine();"
|
|
"}";
|
|
v8::Local<v8::Function> frame_source_line;
|
|
|
|
|
|
// Source for the JavaScript function which picks out the source column for the
|
|
// top frame.
|
|
const char* frame_source_column_source =
|
|
"function frame_source_column(exec_state) {"
|
|
" return exec_state.frame(0).sourceColumn();"
|
|
"}";
|
|
v8::Local<v8::Function> frame_source_column;
|
|
|
|
|
|
// Source for the JavaScript function which picks out the script name for the
|
|
// top frame.
|
|
const char* frame_script_name_source =
|
|
"function frame_script_name(exec_state) {"
|
|
" return exec_state.frame(0).func().script().name();"
|
|
"}";
|
|
v8::Local<v8::Function> frame_script_name;
|
|
|
|
|
|
// Source for the JavaScript function which returns the number of frames.
|
|
static const char* frame_count_source =
|
|
"function frame_count(exec_state) {"
|
|
" return exec_state.frameCount();"
|
|
"}";
|
|
v8::Local<v8::Function> frame_count;
|
|
|
|
|
|
// Global variable to store the last function hit - used by some tests.
|
|
char last_function_hit[80];
|
|
|
|
// Global variable to store the name for last script hit - used by some tests.
|
|
char last_script_name_hit[80];
|
|
|
|
// Global variables to store the last source position - used by some tests.
|
|
int last_source_line = -1;
|
|
int last_source_column = -1;
|
|
|
|
// Debug event handler which counts the break points which have been hit.
|
|
int break_point_hit_count = 0;
|
|
int break_point_hit_count_deoptimize = 0;
|
|
static void DebugEventBreakPointHitCount(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
v8::internal::Isolate* isolate = CcTest::i_isolate();
|
|
Debug* debug = isolate->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
// Count the number of breaks.
|
|
if (event == v8::Break) {
|
|
break_point_hit_count++;
|
|
if (!frame_function_name.IsEmpty()) {
|
|
// Get the name of the function.
|
|
const int argc = 2;
|
|
v8::Local<v8::Value> argv[argc] = {
|
|
exec_state, v8::Integer::New(CcTest::isolate(), 0)};
|
|
v8::Local<v8::Value> result =
|
|
frame_function_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
if (result->IsUndefined()) {
|
|
last_function_hit[0] = '\0';
|
|
} else {
|
|
CHECK(result->IsString());
|
|
v8::Local<v8::String> function_name(result.As<v8::String>());
|
|
function_name->WriteUtf8(last_function_hit);
|
|
}
|
|
}
|
|
|
|
if (!frame_source_line.IsEmpty()) {
|
|
// Get the source line.
|
|
const int argc = 1;
|
|
v8::Local<v8::Value> argv[argc] = {exec_state};
|
|
v8::Local<v8::Value> result =
|
|
frame_source_line->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsNumber());
|
|
last_source_line = result->Int32Value(context).FromJust();
|
|
}
|
|
|
|
if (!frame_source_column.IsEmpty()) {
|
|
// Get the source column.
|
|
const int argc = 1;
|
|
v8::Local<v8::Value> argv[argc] = {exec_state};
|
|
v8::Local<v8::Value> result =
|
|
frame_source_column->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsNumber());
|
|
last_source_column = result->Int32Value(context).FromJust();
|
|
}
|
|
|
|
if (!frame_script_name.IsEmpty()) {
|
|
// Get the script name of the function script.
|
|
const int argc = 1;
|
|
v8::Local<v8::Value> argv[argc] = {exec_state};
|
|
v8::Local<v8::Value> result =
|
|
frame_script_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
if (result->IsUndefined()) {
|
|
last_script_name_hit[0] = '\0';
|
|
} else {
|
|
CHECK(result->IsString());
|
|
v8::Local<v8::String> script_name(result.As<v8::String>());
|
|
script_name->WriteUtf8(last_script_name_hit);
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Debug event handler which counts a number of events and collects the stack
|
|
// height if there is a function compiled for that.
|
|
int exception_hit_count = 0;
|
|
int uncaught_exception_hit_count = 0;
|
|
int last_js_stack_height = -1;
|
|
|
|
static void DebugEventCounterClear() {
|
|
break_point_hit_count = 0;
|
|
exception_hit_count = 0;
|
|
uncaught_exception_hit_count = 0;
|
|
}
|
|
|
|
static void DebugEventCounter(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::Isolate::AllowJavascriptExecutionScope allow_script(CcTest::isolate());
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
v8::Local<v8::Object> event_data = event_details.GetEventData();
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
// Count the number of breaks.
|
|
if (event == v8::Break) {
|
|
break_point_hit_count++;
|
|
} else if (event == v8::Exception) {
|
|
exception_hit_count++;
|
|
|
|
// Check whether the exception was uncaught.
|
|
v8::Local<v8::String> fun_name = v8_str(CcTest::isolate(), "uncaught");
|
|
v8::Local<v8::Function> fun = v8::Local<v8::Function>::Cast(
|
|
event_data->Get(context, fun_name).ToLocalChecked());
|
|
v8::Local<v8::Value> result =
|
|
fun->Call(context, event_data, 0, nullptr).ToLocalChecked();
|
|
if (result->IsTrue()) {
|
|
uncaught_exception_hit_count++;
|
|
}
|
|
}
|
|
|
|
// Collect the JavsScript stack height if the function frame_count is
|
|
// compiled.
|
|
if (!frame_count.IsEmpty()) {
|
|
static const int kArgc = 1;
|
|
v8::Local<v8::Value> argv[kArgc] = {exec_state};
|
|
// Using exec_state as receiver is just to have a receiver.
|
|
v8::Local<v8::Value> result =
|
|
frame_count->Call(context, exec_state, kArgc, argv).ToLocalChecked();
|
|
last_js_stack_height = result->Int32Value(context).FromJust();
|
|
}
|
|
}
|
|
|
|
|
|
// Debug event handler which evaluates a number of expressions when a break
|
|
// point is hit. Each evaluated expression is compared with an expected value.
|
|
// For this debug event handler to work the following two global varaibles
|
|
// must be initialized.
|
|
// checks: An array of expressions and expected results
|
|
// evaluate_check_function: A JavaScript function (see below)
|
|
|
|
// Structure for holding checks to do.
|
|
struct EvaluateCheck {
|
|
const char* expr; // An expression to evaluate when a break point is hit.
|
|
v8::Local<v8::Value> expected; // The expected result.
|
|
};
|
|
|
|
|
|
// Array of checks to do.
|
|
struct EvaluateCheck* checks = nullptr;
|
|
// Source for The JavaScript function which can do the evaluation when a break
|
|
// point is hit.
|
|
const char* evaluate_check_source =
|
|
"function evaluate_check(exec_state, expr, expected) {"
|
|
" return exec_state.frame(0).evaluate(expr).value() === expected;"
|
|
"}";
|
|
v8::Local<v8::Function> evaluate_check_function;
|
|
|
|
// The actual debug event described by the longer comment above.
|
|
static void DebugEventEvaluate(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
v8::Local<v8::Context> context = isolate->GetCurrentContext();
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
if (event == v8::Break) {
|
|
break_point_hit_count++;
|
|
for (int i = 0; checks[i].expr != nullptr; i++) {
|
|
const int argc = 3;
|
|
v8::Local<v8::String> string = v8_str(isolate, checks[i].expr);
|
|
v8::Local<v8::Value> argv[argc] = {exec_state, string,
|
|
checks[i].expected};
|
|
v8::Local<v8::Value> result =
|
|
evaluate_check_function->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
if (!result->IsTrue()) {
|
|
v8::String::Utf8Value utf8(isolate, checks[i].expected);
|
|
V8_Fatal(__FILE__, __LINE__, "%s != %s", checks[i].expr, *utf8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// This debug event listener removes a breakpoint in a function
|
|
i::Handle<i::BreakPoint> debug_event_remove_break_point;
|
|
static void DebugEventRemoveBreakPoint(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Value> data = event_details.GetCallbackData();
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
if (event == v8::Break) {
|
|
break_point_hit_count++;
|
|
CHECK(data->IsFunction());
|
|
ClearBreakPoint(debug_event_remove_break_point);
|
|
}
|
|
}
|
|
|
|
|
|
// Debug event handler which counts break points hit and performs a step
|
|
// afterwards.
|
|
StepAction step_action = StepIn; // Step action to perform when stepping.
|
|
static void DebugEventStep(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
if (event == v8::Break) {
|
|
break_point_hit_count++;
|
|
PrepareStep(step_action);
|
|
}
|
|
}
|
|
|
|
|
|
// Debug event handler which counts break points hit and performs a step
|
|
// afterwards. For each call the expected function is checked.
|
|
// For this debug event handler to work the following two global varaibles
|
|
// must be initialized.
|
|
// expected_step_sequence: An array of the expected function call sequence.
|
|
// frame_function_name: A JavaScript function (see below).
|
|
|
|
// String containing the expected function call sequence. Note: this only works
|
|
// if functions have name length of one.
|
|
const char* expected_step_sequence = nullptr;
|
|
|
|
// The actual debug event described by the longer comment above.
|
|
static void DebugEventStepSequence(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
if (event == v8::Break || event == v8::Exception) {
|
|
// Check that the current function is the expected.
|
|
CHECK(break_point_hit_count <
|
|
StrLength(expected_step_sequence));
|
|
const int argc = 2;
|
|
v8::Local<v8::Value> argv[argc] = {exec_state,
|
|
v8::Integer::New(CcTest::isolate(), 0)};
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
v8::Local<v8::Value> result =
|
|
frame_function_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsString());
|
|
v8::String::Utf8Value function_name(
|
|
CcTest::isolate(), result->ToString(context).ToLocalChecked());
|
|
CHECK_EQ(1, StrLength(*function_name));
|
|
CHECK_EQ((*function_name)[0],
|
|
expected_step_sequence[break_point_hit_count]);
|
|
|
|
// Perform step.
|
|
break_point_hit_count++;
|
|
PrepareStep(step_action);
|
|
}
|
|
}
|
|
|
|
|
|
// Debug event handler which performs a garbage collection.
|
|
static void DebugEventBreakPointCollectGarbage(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
// 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.
|
|
if (event == v8::Break) {
|
|
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.
|
|
static void DebugEventBreak(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
if (event == v8::Break) {
|
|
// 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::DebugBreak(CcTest::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;
|
|
static void DebugEventBreakMax(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Isolate* v8_isolate = CcTest::isolate();
|
|
v8::internal::Isolate* isolate = CcTest::i_isolate();
|
|
v8::internal::Debug* debug = isolate->debug();
|
|
// When hitting a debug event listener there must be a break set.
|
|
CHECK_NE(debug->break_id(), 0);
|
|
|
|
if (event == v8::Break) {
|
|
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::debug::DebugBreak(v8_isolate);
|
|
|
|
} 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// --- M e s s a g e C a l l b a c k
|
|
|
|
|
|
// Message callback which counts the number of messages.
|
|
int message_callback_count = 0;
|
|
|
|
static void MessageCallbackCountClear() {
|
|
message_callback_count = 0;
|
|
}
|
|
|
|
static void MessageCallbackCount(v8::Local<v8::Message> message,
|
|
v8::Local<v8::Value> data) {
|
|
message_callback_count++;
|
|
}
|
|
|
|
|
|
// --- 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) {
|
|
DebugLocalContext 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;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){bar=0;}", "foo");
|
|
|
|
// Run without breakpoints.
|
|
foo->Call(env.context(), 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.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that a break point can be set at an IC store location.
|
|
TEST(BreakPointCondition) {
|
|
break_point_hit_count = 0;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Test that a break point can be set at an IC load location.
|
|
TEST(BreakPointICLoad) {
|
|
break_point_hit_count = 0;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
CompileRunChecked(env->GetIsolate(), "bar=1");
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){var x=bar;}", "foo");
|
|
|
|
// Run without breakpoints.
|
|
foo->Call(env.context(), 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.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that a break point can be set at an IC call location.
|
|
TEST(BreakPointICCall) {
|
|
break_point_hit_count = 0;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
CompileRunChecked(env->GetIsolate(), "function bar(){}");
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){bar();}", "foo");
|
|
|
|
// Run without breakpoints.
|
|
foo->Call(env.context(), 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.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
SetDebugEventListener(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;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointCollectGarbage);
|
|
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.context();
|
|
|
|
// 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);
|
|
|
|
SetDebugEventListener(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;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointCollectGarbage);
|
|
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.context();
|
|
|
|
// 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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that a break point can be set at a return store location.
|
|
TEST(BreakPointReturn) {
|
|
break_point_hit_count = 0;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Create a functions for checking the source line and column when hitting
|
|
// a break point.
|
|
frame_source_line = CompileFunction(&env,
|
|
frame_source_line_source,
|
|
"frame_source_line");
|
|
frame_source_column = CompileFunction(&env,
|
|
frame_source_column_source,
|
|
"frame_source_column");
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){}", "foo");
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
// Run without breakpoints.
|
|
foo->Call(context, 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(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CHECK_EQ(0, last_source_line);
|
|
CHECK_EQ(15, last_source_column);
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
CHECK_EQ(0, last_source_line);
|
|
CHECK_EQ(15, last_source_column);
|
|
|
|
// Run without breakpoints.
|
|
ClearBreakPoint(bp);
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBuiltin) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointJSBuiltin) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBoundBuiltin) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointConstructorBuiltin) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
v8::Local<v8::Function> builtin;
|
|
i::Handle<i::BreakPoint> bp;
|
|
|
|
// === Test constructor builtin (for ones with normal construct stubs) ===
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlinedBuiltin) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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(
|
|
"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("%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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlineBoundBuiltin) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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(
|
|
"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("%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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlinedConstructorBuiltin) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
i::FLAG_experimental_inline_promise_constructor = true;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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(
|
|
"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("%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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBuiltinConcurrentOpt) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
i::FLAG_block_concurrent_recompilation = true;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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(
|
|
"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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBuiltinTFOperator) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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(
|
|
"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("%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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointBuiltinNewContext) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
void NoOpFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
args.GetReturnValue().Set(v8_num(2));
|
|
}
|
|
|
|
TEST(BreakPointApiFunction) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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.context()).ToLocalChecked();
|
|
|
|
env->Global()->Set(env.context(), 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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlineApiFunction) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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.context()).ToLocalChecked();
|
|
|
|
env->Global()->Set(env.context(), v8_str("f"), function).ToChecked();
|
|
CompileRun("function g() { return 1 + f(); }");
|
|
|
|
// === 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);
|
|
|
|
SetDebugEventListener(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;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
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 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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(BreakPointInlining) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
break_point_hit_count = 0;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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(
|
|
"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("%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);
|
|
|
|
SetDebugEventListener(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;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointCollectGarbage);
|
|
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);
|
|
|
|
SetDebugEventListener(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;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
|
|
// Test that it is possible to remove the last break point for a function
|
|
// inside the break handling of that break point.
|
|
TEST(RemoveBreakPointInBreak) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
v8::Local<v8::Function> foo =
|
|
CompileFunction(&env, "function foo(){a=1;}", "foo");
|
|
|
|
// Register the debug event listener pasing the function
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventRemoveBreakPoint, foo);
|
|
|
|
debug_event_remove_break_point = SetBreakPoint(foo, 0);
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(0, break_point_hit_count);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that the debugger statement causes a break.
|
|
TEST(DebuggerStatement) {
|
|
break_point_hit_count = 0;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
v8::Local<v8::Context> context = env.context();
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test setting a breakpoint on the debugger statement.
|
|
TEST(DebuggerStatementBreakpoint) {
|
|
break_point_hit_count = 0;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
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);
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that the evaluation of expressions when a break point is hit generates
|
|
// the correct results.
|
|
TEST(DebugEvaluate) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
// Create a function for checking the evaluation when hitting a break point.
|
|
evaluate_check_function = CompileFunction(&env,
|
|
evaluate_check_source,
|
|
"evaluate_check");
|
|
// Register the debug event listener
|
|
SetDebugEventListener(isolate, DebugEventEvaluate);
|
|
|
|
// Different expected vaules of x and a when in a break point (u = undefined,
|
|
// d = Hello, world!).
|
|
struct EvaluateCheck checks_uu[] = {{"x", v8::Undefined(isolate)},
|
|
{"a", v8::Undefined(isolate)},
|
|
{nullptr, v8::Local<v8::Value>()}};
|
|
struct EvaluateCheck checks_hu[] = {
|
|
{"x", v8_str(env->GetIsolate(), "Hello, world!")},
|
|
{"a", v8::Undefined(isolate)},
|
|
{nullptr, v8::Local<v8::Value>()}};
|
|
struct EvaluateCheck checks_hh[] = {
|
|
{"x", v8_str(env->GetIsolate(), "Hello, world!")},
|
|
{"a", v8_str(env->GetIsolate(), "Hello, world!")},
|
|
{nullptr, v8::Local<v8::Value>()}};
|
|
|
|
// Simple test function. The "y=0" is in the function foo to provide a break
|
|
// location. For "y=0" the "y" is at position 15 in the foo function
|
|
// therefore setting breakpoint at position 15 will break at "y=0" and
|
|
// setting it higher will break after.
|
|
v8::Local<v8::Function> foo = CompileFunction(&env,
|
|
"function foo(x) {"
|
|
" var a;"
|
|
" y=0;" // To ensure break location 1.
|
|
" a=x;"
|
|
" y=0;" // To ensure break location 2.
|
|
"}",
|
|
"foo");
|
|
const int foo_break_position_1 = 15;
|
|
const int foo_break_position_2 = 29;
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Arguments with one parameter "Hello, world!"
|
|
v8::Local<v8::Value> argv_foo[1] = {
|
|
v8_str(env->GetIsolate(), "Hello, world!")};
|
|
|
|
// Call foo with breakpoint set before a=x and undefined as parameter.
|
|
i::Handle<i::BreakPoint> bp = SetBreakPoint(foo, foo_break_position_1);
|
|
checks = checks_uu;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// Call foo with breakpoint set before a=x and parameter "Hello, world!".
|
|
checks = checks_hu;
|
|
foo->Call(context, env->Global(), 1, argv_foo).ToLocalChecked();
|
|
|
|
// Call foo with breakpoint set after a=x and parameter "Hello, world!".
|
|
ClearBreakPoint(bp);
|
|
SetBreakPoint(foo, foo_break_position_2);
|
|
checks = checks_hh;
|
|
foo->Call(context, env->Global(), 1, argv_foo).ToLocalChecked();
|
|
|
|
// Test that overriding Object.prototype will not interfere into evaluation
|
|
// on call frame.
|
|
v8::Local<v8::Function> zoo =
|
|
CompileFunction(&env,
|
|
"x = undefined;"
|
|
"function zoo(t) {"
|
|
" var a=x;"
|
|
" Object.prototype.x = 42;"
|
|
" x=t;"
|
|
" y=0;" // To ensure break location.
|
|
" delete Object.prototype.x;"
|
|
" x=a;"
|
|
"}",
|
|
"zoo");
|
|
const int zoo_break_position = 50;
|
|
|
|
// Arguments with one parameter "Hello, world!"
|
|
v8::Local<v8::Value> argv_zoo[1] = {
|
|
v8_str(env->GetIsolate(), "Hello, world!")};
|
|
|
|
// Call zoo with breakpoint set at y=0.
|
|
DebugEventCounterClear();
|
|
bp = SetBreakPoint(zoo, zoo_break_position);
|
|
checks = checks_hu;
|
|
zoo->Call(context, env->Global(), 1, argv_zoo).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
ClearBreakPoint(bp);
|
|
|
|
// Test function with an inner function. The "y=0" is in function barbar
|
|
// to provide a break location. For "y=0" the "y" is at position 8 in the
|
|
// barbar function therefore setting breakpoint at position 8 will break at
|
|
// "y=0" and setting it higher will break after.
|
|
v8::Local<v8::Function> bar = CompileFunction(&env,
|
|
"y = 0;"
|
|
"x = 'Goodbye, world!';"
|
|
"function bar(x, b) {"
|
|
" var a;"
|
|
" function barbar() {"
|
|
" y=0; /* To ensure break location.*/"
|
|
" a=x;"
|
|
" };"
|
|
" barbar();"
|
|
" y=0;a=x;"
|
|
"}",
|
|
"bar");
|
|
const int barbar_break_position = 8;
|
|
|
|
// Call bar setting breakpoint before a=x in barbar and undefined as
|
|
// parameter.
|
|
checks = checks_uu;
|
|
v8::Local<v8::Value> argv_bar_1[2] = {
|
|
v8::Undefined(isolate), v8::Number::New(isolate, barbar_break_position)};
|
|
bar->Call(context, env->Global(), 2, argv_bar_1).ToLocalChecked();
|
|
|
|
// Call bar setting breakpoint before a=x in barbar and parameter
|
|
// "Hello, world!".
|
|
checks = checks_hu;
|
|
v8::Local<v8::Value> argv_bar_2[2] = {
|
|
v8_str(env->GetIsolate(), "Hello, world!"),
|
|
v8::Number::New(env->GetIsolate(), barbar_break_position)};
|
|
bar->Call(context, env->Global(), 2, argv_bar_2).ToLocalChecked();
|
|
|
|
// Call bar setting breakpoint after a=x in barbar and parameter
|
|
// "Hello, world!".
|
|
checks = checks_hh;
|
|
v8::Local<v8::Value> argv_bar_3[2] = {
|
|
v8_str(env->GetIsolate(), "Hello, world!"),
|
|
v8::Number::New(env->GetIsolate(), barbar_break_position + 1)};
|
|
bar->Call(context, env->Global(), 2, argv_bar_3).ToLocalChecked();
|
|
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
int debugEventCount = 0;
|
|
static void CheckDebugEvent(const v8::Debug::EventDetails& eventDetails) {
|
|
if (eventDetails.GetEvent() == v8::Break) ++debugEventCount;
|
|
}
|
|
|
|
|
|
// Test that the conditional breakpoints work event if code generation from
|
|
// strings is prohibited in the debugee context.
|
|
TEST(ConditionalBreakpointWithCodeGenerationDisallowed) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
env.ExposeDebug();
|
|
|
|
SetDebugEventListener(env->GetIsolate(), CheckDebugEvent);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
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");
|
|
|
|
debugEventCount = 0;
|
|
env->AllowCodeGenerationFromStrings(false);
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, debugEventCount);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Simple test of the stepping mechanism using only store ICs.
|
|
TEST(DebugStepLinear) {
|
|
DebugLocalContext 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.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
SetBreakPoint(foo, 3);
|
|
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
v8::Local<v8::Context> context = env.context();
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
|
|
// With stepping all break locations are hit.
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test of the stepping mechanism for keyed load in a loop.
|
|
TEST(DebugStepKeyedLoadLoop) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
// 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.context();
|
|
// 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);
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test of the stepping mechanism for keyed store in a loop.
|
|
TEST(DebugStepKeyedStoreLoop) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
// 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.context();
|
|
// 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);
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test of the stepping mechanism for named load in a loop.
|
|
TEST(DebugStepNamedLoadLoop) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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);
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
static void DoDebugStepNamedStoreLoop(int expected) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
// Create a function for testing stepping of named store.
|
|
v8::Local<v8::Context> context = env.context();
|
|
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);
|
|
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);
|
|
|
|
SetDebugEventListener(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) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepDeclarations) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepLocals) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepIf) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepSwitch) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
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.
|
|
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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepWhile) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
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.
|
|
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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepDoWhile) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
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.
|
|
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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepFor) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
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.
|
|
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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepForContinue) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepForBreak) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
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.
|
|
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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepForIn) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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 = ..."
|
|
|
|
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 = ..."
|
|
|
|
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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugStepWith) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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 = {};"
|
|
|
|
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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugConditional) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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;"
|
|
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
|
|
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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(StepInOutSimple) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Create a function for checking the function when hitting a break point.
|
|
frame_function_name = CompileFunction(&env,
|
|
frame_function_name_source,
|
|
"frame_function_name");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStepSequence);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src = "function a() {b();c();}; "
|
|
"function b() {c();}; "
|
|
"function c() {}; "
|
|
"a(); b(); c()";
|
|
v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
|
|
SetBreakPoint(a, 0);
|
|
|
|
// Step through invocation of a with step in.
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "abcbaca";
|
|
a->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of a with step next.
|
|
step_action = StepNext;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "aaa";
|
|
a->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of a with step out.
|
|
step_action = StepOut;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "a";
|
|
a->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(StepInOutTree) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Create a function for checking the function when hitting a break point.
|
|
frame_function_name = CompileFunction(&env,
|
|
frame_function_name_source,
|
|
"frame_function_name");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStepSequence);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src = "function a() {b(c(d()),d());c(d());d()}; "
|
|
"function b(x,y) {c();}; "
|
|
"function c(x) {}; "
|
|
"function d() {}; "
|
|
"a(); b(); c(); d()";
|
|
v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
|
|
SetBreakPoint(a, 0);
|
|
|
|
// Step through invocation of a with step in.
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "adacadabcbadacada";
|
|
a->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of a with step next.
|
|
step_action = StepNext;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "aaaa";
|
|
a->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of a with step out.
|
|
step_action = StepOut;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "a";
|
|
a->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(StepInOutBranch) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Create a function for checking the function when hitting a break point.
|
|
frame_function_name = CompileFunction(&env,
|
|
frame_function_name_source,
|
|
"frame_function_name");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStepSequence);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create a function for testing stepping. Run it to allow it to get
|
|
// optimized.
|
|
const char* src = "function a() {b(false);c();}; "
|
|
"function b(x) {if(x){c();};}; "
|
|
"function c() {}; "
|
|
"a(); b(); c()";
|
|
v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
|
|
SetBreakPoint(a, 0);
|
|
|
|
// Step through invocation of a.
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "abbaca";
|
|
a->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that step in does not step into native functions.
|
|
TEST(DebugStepNatives) {
|
|
DebugLocalContext 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.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that step in works with function.apply.
|
|
TEST(DebugStepFunctionApply) {
|
|
DebugLocalContext 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.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStep);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that step in works with function.call.
|
|
TEST(DebugStepFunctionCall) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
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);
|
|
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that step in works with Function.call.apply.
|
|
TEST(DebugStepFunctionCallApply) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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.
|
|
SetDebugEventListener(isolate, DebugEventStep);
|
|
step_action = StepIn;
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(6, break_point_hit_count);
|
|
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Register a debug event listener which just counts.
|
|
SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
|
|
|
|
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);
|
|
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Tests that breakpoint will be hit if it's set in script.
|
|
TEST(PauseInScript) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
|
|
env.ExposeDebug();
|
|
|
|
// Register a debug event listener which counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventCounter);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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::BreakPoint> break_point =
|
|
isolate->factory()->NewBreakPoint(0, isolate->factory()->empty_string());
|
|
int position = 0;
|
|
i::Handle<i::Script> i_script(
|
|
i::Script::cast(v8::Utils::OpenHandle(*script)->shared()->script()));
|
|
isolate->debug()->SetBreakPointForScript(i_script, break_point, &position);
|
|
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 event listener.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
static void DebugEventCounterCheck(int caught, int uncaught, int message) {
|
|
CHECK_EQ(caught, exception_hit_count);
|
|
CHECK_EQ(uncaught, uncaught_exception_hit_count);
|
|
CHECK_EQ(message, message_callback_count);
|
|
}
|
|
|
|
|
|
// Test break on exceptions. For each exception break combination the number
|
|
// of debug event exception callbacks and message callbacks are collected. The
|
|
// number of debug event exception callbacks are used to check that the
|
|
// debugger is called correctly and the number of message callbacks is used to
|
|
// check that uncaught exceptions are still returned even if there is a break
|
|
// for them.
|
|
TEST(BreakOnException) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
env.ExposeDebug();
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create functions for testing break on exception.
|
|
CompileFunction(&env, "function throws(){throw 1;}", "throws");
|
|
v8::Local<v8::Function> caught =
|
|
CompileFunction(&env,
|
|
"function caught(){try {throws();} catch(e) {};}",
|
|
"caught");
|
|
v8::Local<v8::Function> notCaught =
|
|
CompileFunction(&env, "function notCaught(){throws();}", "notCaught");
|
|
v8::Local<v8::Function> notCaughtFinally = CompileFunction(
|
|
&env, "function notCaughtFinally(){try{throws();}finally{}}",
|
|
"notCaughtFinally");
|
|
// In this edge case, even though this finally does not propagate the
|
|
// exception, the debugger considers this uncaught, since we want to break
|
|
// at the first throw for the general case where finally implicitly rethrows.
|
|
v8::Local<v8::Function> edgeCaseFinally = CompileFunction(
|
|
&env, "function caughtFinally(){L:try{throws();}finally{break L;}}",
|
|
"caughtFinally");
|
|
|
|
env->GetIsolate()->AddMessageListener(MessageCallbackCount);
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventCounter);
|
|
|
|
// Initial state should be no break on exceptions.
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
|
|
// No break on exception
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnException(false, false);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
|
|
// Break on uncaught exception
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnException(false, true);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(1, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(3, 3, 2);
|
|
|
|
// Break on exception and uncaught exception
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnException(true, true);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(1, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(3, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(4, 3, 2);
|
|
|
|
// Break on exception
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnException(true, false);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(1, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(3, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(4, 3, 2);
|
|
|
|
// No break on exception using JavaScript
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnExceptionFromJS(env->GetIsolate(), false, false);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
|
|
// Break on uncaught exception using JavaScript
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnExceptionFromJS(env->GetIsolate(), false, true);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(1, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(3, 3, 2);
|
|
|
|
// Break on exception and uncaught exception using JavaScript
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnExceptionFromJS(env->GetIsolate(), true, true);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(1, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(3, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(4, 3, 2);
|
|
|
|
// Break on exception using JavaScript
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnExceptionFromJS(env->GetIsolate(), true, false);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(1, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(3, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(4, 3, 2);
|
|
|
|
// No break on exception using native API
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnExceptionFromAPI(env->GetIsolate(),
|
|
v8::debug::NoBreakOnException);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 2);
|
|
|
|
// // Break on uncaught exception using native API
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnExceptionFromAPI(env->GetIsolate(),
|
|
v8::debug::BreakOnUncaughtException);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(0, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(1, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(3, 3, 2);
|
|
|
|
// // Break on exception and uncaught exception using native API
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
ChangeBreakOnExceptionFromAPI(env->GetIsolate(),
|
|
v8::debug::BreakOnAnyException);
|
|
caught->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(1, 0, 0);
|
|
CHECK(notCaught->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(2, 1, 1);
|
|
CHECK(notCaughtFinally->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
DebugEventCounterCheck(3, 2, 2);
|
|
edgeCaseFinally->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
DebugEventCounterCheck(4, 3, 2);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
env->GetIsolate()->RemoveMessageListeners(MessageCallbackCount);
|
|
}
|
|
|
|
|
|
static void try_finally_original_message(v8::Local<v8::Message> message,
|
|
v8::Local<v8::Value> data) {
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
CHECK_EQ(2, message->GetLineNumber(context).FromJust());
|
|
CHECK_EQ(2, message->GetStartColumn(context).FromJust());
|
|
message_callback_count++;
|
|
}
|
|
|
|
|
|
TEST(TryFinallyOriginalMessage) {
|
|
// Test that the debugger plays nicely with the pending message.
|
|
message_callback_count = 0;
|
|
DebugEventCounterClear();
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
isolate->AddMessageListener(try_finally_original_message);
|
|
SetDebugEventListener(isolate, DebugEventCounter);
|
|
ChangeBreakOnException(true, true);
|
|
v8::HandleScope scope(isolate);
|
|
CompileRun(
|
|
"try {\n"
|
|
" throw 1;\n"
|
|
"} finally {\n"
|
|
"}\n");
|
|
DebugEventCounterCheck(1, 1, 1);
|
|
SetDebugEventListener(isolate, nullptr);
|
|
isolate->RemoveMessageListeners(try_finally_original_message);
|
|
}
|
|
|
|
|
|
// Test break on exception from compiler errors. When compiling using
|
|
// v8::Script::Compile there is no JavaScript stack whereas when compiling using
|
|
// eval there are JavaScript frames.
|
|
TEST(BreakOnCompileException) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// For this test, we want to break on uncaught exceptions:
|
|
ChangeBreakOnException(false, true);
|
|
|
|
// Create a function for checking the function when hitting a break point.
|
|
frame_count = CompileFunction(&env, frame_count_source, "frame_count");
|
|
|
|
env->GetIsolate()->AddMessageListener(MessageCallbackCount);
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventCounter);
|
|
|
|
DebugEventCounterClear();
|
|
MessageCallbackCountClear();
|
|
|
|
// Check initial state.
|
|
CHECK_EQ(0, exception_hit_count);
|
|
CHECK_EQ(0, uncaught_exception_hit_count);
|
|
CHECK_EQ(0, message_callback_count);
|
|
CHECK_EQ(-1, last_js_stack_height);
|
|
|
|
// Throws SyntaxError: Unexpected end of input
|
|
CHECK(
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), "+++")).IsEmpty());
|
|
// Exceptions with no stack are skipped.
|
|
CHECK_EQ(0, exception_hit_count);
|
|
CHECK_EQ(0, uncaught_exception_hit_count);
|
|
CHECK_EQ(1, message_callback_count);
|
|
CHECK_EQ(0, last_js_stack_height); // No JavaScript stack.
|
|
|
|
// Throws SyntaxError: Unexpected identifier
|
|
CHECK(
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), "x x")).IsEmpty());
|
|
// Exceptions with no stack are skipped.
|
|
CHECK_EQ(0, exception_hit_count);
|
|
CHECK_EQ(0, uncaught_exception_hit_count);
|
|
CHECK_EQ(2, message_callback_count);
|
|
CHECK_EQ(0, last_js_stack_height); // No JavaScript stack.
|
|
|
|
// Throws SyntaxError: Unexpected end of input
|
|
CHECK(v8::Script::Compile(context, v8_str(env->GetIsolate(), "eval('+++')"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.IsEmpty());
|
|
CHECK_EQ(1, exception_hit_count);
|
|
CHECK_EQ(1, uncaught_exception_hit_count);
|
|
CHECK_EQ(3, message_callback_count);
|
|
CHECK_EQ(1, last_js_stack_height);
|
|
|
|
// Throws SyntaxError: Unexpected identifier
|
|
CHECK(v8::Script::Compile(context, v8_str(env->GetIsolate(), "eval('x x')"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.IsEmpty());
|
|
CHECK_EQ(2, exception_hit_count);
|
|
CHECK_EQ(2, uncaught_exception_hit_count);
|
|
CHECK_EQ(4, message_callback_count);
|
|
CHECK_EQ(1, last_js_stack_height);
|
|
}
|
|
|
|
|
|
TEST(StepWithException) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// For this test, we want to break on uncaught exceptions:
|
|
ChangeBreakOnException(false, true);
|
|
|
|
// Create a function for checking the function when hitting a break point.
|
|
frame_function_name = CompileFunction(&env,
|
|
frame_function_name_source,
|
|
"frame_function_name");
|
|
|
|
// Register a debug event listener which steps and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStepSequence);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create functions for testing stepping.
|
|
const char* src = "function a() { n(); }; "
|
|
"function b() { c(); }; "
|
|
"function c() { n(); }; "
|
|
"function d() { x = 1; try { e(); } catch(x) { x = 2; } }; "
|
|
"function e() { n(); }; "
|
|
"function f() { x = 1; try { g(); } catch(x) { x = 2; } }; "
|
|
"function g() { h(); }; "
|
|
"function h() { x = 1; throw 1; }; ";
|
|
|
|
// Step through invocation of a.
|
|
ClearStepping();
|
|
v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
|
|
SetBreakPoint(a, 0);
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "aa";
|
|
CHECK(a->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of b + c.
|
|
ClearStepping();
|
|
v8::Local<v8::Function> b = CompileFunction(&env, src, "b");
|
|
SetBreakPoint(b, 0);
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "bcc";
|
|
CHECK(b->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of d + e.
|
|
ClearStepping();
|
|
v8::Local<v8::Function> d = CompileFunction(&env, src, "d");
|
|
SetBreakPoint(d, 0);
|
|
ChangeBreakOnException(false, true);
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "ddedd";
|
|
d->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of d + e now with break on caught exceptions.
|
|
ChangeBreakOnException(true, true);
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "ddeedd";
|
|
d->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of f + g + h.
|
|
ClearStepping();
|
|
v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
|
|
SetBreakPoint(f, 0);
|
|
ChangeBreakOnException(false, true);
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "ffghhff";
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Step through invocation of f + g + h now with break on caught exceptions.
|
|
ChangeBreakOnException(true, true);
|
|
step_action = StepIn;
|
|
break_point_hit_count = 0;
|
|
expected_step_sequence = "ffghhhff";
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(StrLength(expected_step_sequence),
|
|
break_point_hit_count);
|
|
|
|
// Get rid of the debug event listener.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
TEST(DebugBreak) {
|
|
i::FLAG_stress_compaction = false;
|
|
#ifdef VERIFY_HEAP
|
|
i::FLAG_verify_heap = true;
|
|
#endif
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
SetDebugEventListener(isolate, DebugEventBreak);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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::DebugBreak(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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
static void DebugScopingListener(const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
if (event != v8::Exception) return;
|
|
|
|
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());
|
|
CHECK(scopes->GetFunction().IsEmpty());
|
|
|
|
scopes->Advance();
|
|
CHECK(scopes->Done());
|
|
}
|
|
|
|
TEST(DebugBreakInWrappedScript) {
|
|
i::FLAG_stress_compaction = false;
|
|
#ifdef VERIFY_HEAP
|
|
i::FLAG_verify_heap = true;
|
|
#endif
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
SetDebugEventListener(isolate, DebugScopingListener);
|
|
|
|
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.context(), &script_source, 0, nullptr, 0, nullptr)
|
|
.ToLocalChecked();
|
|
v8::Local<v8::Value> result =
|
|
fun->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK(result->IsString());
|
|
CHECK(v8::Local<v8::String>::Cast(result)
|
|
->Equals(env.context(), v8_str(expect))
|
|
.FromJust());
|
|
}
|
|
|
|
// Get rid of the debug event listener.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(DebugBreakWithoutJS) {
|
|
i::FLAG_stress_compaction = false;
|
|
#ifdef VERIFY_HEAP
|
|
i::FLAG_verify_heap = true;
|
|
#endif
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::Local<v8::Context> context = env.context();
|
|
v8::HandleScope scope(isolate);
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
SetDebugEventListener(isolate, DebugEventBreak);
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::DebugBreak(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.
|
|
SetDebugEventListener(isolate, 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) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventCounter);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// 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::DebugBreak(env->GetIsolate());
|
|
v8::debug::CancelDebugBreak(env->GetIsolate());
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::DebugBreak(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::DebugBreak(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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
TEST(DisableDebuggerStatement) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventCounter);
|
|
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);
|
|
}
|
|
|
|
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.
|
|
SetDebugEventListener(isolate, DebugEventCounter);
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::DebugBreak(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(new 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.
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
static void NamedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
|
|
v8::Local<v8::Array> result = v8::Array::New(info.GetIsolate(), 3);
|
|
v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
|
|
CHECK(result->Set(context, v8::Integer::New(info.GetIsolate(), 0),
|
|
v8_str(info.GetIsolate(), "a"))
|
|
.FromJust());
|
|
CHECK(result->Set(context, v8::Integer::New(info.GetIsolate(), 1),
|
|
v8_str(info.GetIsolate(), "b"))
|
|
.FromJust());
|
|
CHECK(result->Set(context, v8::Integer::New(info.GetIsolate(), 2),
|
|
v8_str(info.GetIsolate(), "c"))
|
|
.FromJust());
|
|
info.GetReturnValue().Set(result);
|
|
}
|
|
|
|
|
|
static void IndexedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
|
|
v8::Isolate* isolate = info.GetIsolate();
|
|
v8::Local<v8::Array> result = v8::Array::New(isolate, 2);
|
|
v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
|
|
CHECK(result->Set(context, v8::Integer::New(isolate, 0),
|
|
v8::Number::New(isolate, 1))
|
|
.FromJust());
|
|
CHECK(result->Set(context, v8::Integer::New(isolate, 1),
|
|
v8::Number::New(isolate, 10))
|
|
.FromJust());
|
|
info.GetReturnValue().Set(result);
|
|
}
|
|
|
|
|
|
static void NamedGetter(v8::Local<v8::Name> name,
|
|
const v8::PropertyCallbackInfo<v8::Value>& info) {
|
|
if (name->IsSymbol()) return;
|
|
v8::String::Utf8Value n(CcTest::isolate(), v8::Local<v8::String>::Cast(name));
|
|
if (strcmp(*n, "a") == 0) {
|
|
info.GetReturnValue().Set(v8_str(info.GetIsolate(), "AA"));
|
|
return;
|
|
} else if (strcmp(*n, "b") == 0) {
|
|
info.GetReturnValue().Set(v8_str(info.GetIsolate(), "BB"));
|
|
return;
|
|
} else if (strcmp(*n, "c") == 0) {
|
|
info.GetReturnValue().Set(v8_str(info.GetIsolate(), "CC"));
|
|
return;
|
|
} else {
|
|
info.GetReturnValue().SetUndefined();
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
static void IndexedGetter(uint32_t index,
|
|
const v8::PropertyCallbackInfo<v8::Value>& info) {
|
|
info.GetReturnValue().Set(static_cast<double>(index + 1));
|
|
}
|
|
|
|
|
|
TEST(InterceptorPropertyMirror) {
|
|
// Create a V8 environment with debug access.
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create object with named interceptor.
|
|
v8::Local<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
|
|
named->SetHandler(v8::NamedPropertyHandlerConfiguration(
|
|
NamedGetter, nullptr, nullptr, nullptr, NamedEnum));
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(isolate, "intercepted_named"),
|
|
named->NewInstance(context).ToLocalChecked())
|
|
.FromJust());
|
|
|
|
// Create object with indexed interceptor.
|
|
v8::Local<v8::ObjectTemplate> indexed = v8::ObjectTemplate::New(isolate);
|
|
indexed->SetHandler(v8::IndexedPropertyHandlerConfiguration(
|
|
IndexedGetter, nullptr, nullptr, nullptr, IndexedEnum));
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(isolate, "intercepted_indexed"),
|
|
indexed->NewInstance(context).ToLocalChecked())
|
|
.FromJust());
|
|
|
|
// Create object with both named and indexed interceptor.
|
|
v8::Local<v8::ObjectTemplate> both = v8::ObjectTemplate::New(isolate);
|
|
both->SetHandler(v8::NamedPropertyHandlerConfiguration(
|
|
NamedGetter, nullptr, nullptr, nullptr, NamedEnum));
|
|
both->SetHandler(v8::IndexedPropertyHandlerConfiguration(
|
|
IndexedGetter, nullptr, nullptr, nullptr, IndexedEnum));
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(isolate, "intercepted_both"),
|
|
both->NewInstance(context).ToLocalChecked())
|
|
.FromJust());
|
|
|
|
// Get mirrors for the three objects with interceptor.
|
|
CompileRun(
|
|
"var named_mirror = debug.MakeMirror(intercepted_named);"
|
|
"var indexed_mirror = debug.MakeMirror(intercepted_indexed);"
|
|
"var both_mirror = debug.MakeMirror(intercepted_both)");
|
|
CHECK(CompileRun("named_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("indexed_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("both_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
|
|
// Get the property names from the interceptors
|
|
CompileRun(
|
|
"named_names = named_mirror.propertyNames();"
|
|
"indexed_names = indexed_mirror.propertyNames();"
|
|
"both_names = both_mirror.propertyNames()");
|
|
CHECK_EQ(3, CompileRun("named_names.length")->Int32Value(context).FromJust());
|
|
CHECK_EQ(2,
|
|
CompileRun("indexed_names.length")->Int32Value(context).FromJust());
|
|
CHECK_EQ(5, CompileRun("both_names.length")->Int32Value(context).FromJust());
|
|
|
|
// Check the expected number of properties.
|
|
const char* source;
|
|
source = "named_mirror.properties().length";
|
|
CHECK_EQ(3, CompileRun(source)->Int32Value(context).FromJust());
|
|
|
|
source = "indexed_mirror.properties().length";
|
|
CHECK_EQ(2, CompileRun(source)->Int32Value(context).FromJust());
|
|
|
|
source = "both_mirror.properties().length";
|
|
CHECK_EQ(5, CompileRun(source)->Int32Value(context).FromJust());
|
|
|
|
// Get the interceptor properties for the object with only named interceptor.
|
|
CompileRun("var named_values = named_mirror.properties()");
|
|
|
|
// Check that the properties are interceptor properties.
|
|
for (int i = 0; i < 3; i++) {
|
|
EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
|
|
SNPrintF(buffer,
|
|
"named_values[%d] instanceof debug.PropertyMirror", i);
|
|
CHECK(CompileRun(buffer.start())->BooleanValue(context).FromJust());
|
|
|
|
SNPrintF(buffer, "named_values[%d].isNative()", i);
|
|
CHECK(CompileRun(buffer.start())->BooleanValue(context).FromJust());
|
|
}
|
|
|
|
// Get the interceptor properties for the object with only indexed
|
|
// interceptor.
|
|
CompileRun("var indexed_values = indexed_mirror.properties()");
|
|
|
|
// Check that the properties are interceptor properties.
|
|
for (int i = 0; i < 2; i++) {
|
|
EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
|
|
SNPrintF(buffer,
|
|
"indexed_values[%d] instanceof debug.PropertyMirror", i);
|
|
CHECK(CompileRun(buffer.start())->BooleanValue(context).FromJust());
|
|
}
|
|
|
|
// Get the interceptor properties for the object with both types of
|
|
// interceptors.
|
|
CompileRun("var both_values = both_mirror.properties()");
|
|
|
|
// Check that the properties are interceptor properties.
|
|
for (int i = 0; i < 5; i++) {
|
|
EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
|
|
SNPrintF(buffer, "both_values[%d] instanceof debug.PropertyMirror", i);
|
|
CHECK(CompileRun(buffer.start())->BooleanValue(context).FromJust());
|
|
}
|
|
|
|
// Check the property names.
|
|
source = "both_values[0].name() == '1'";
|
|
CHECK(CompileRun(source)->BooleanValue(context).FromJust());
|
|
|
|
source = "both_values[1].name() == '10'";
|
|
CHECK(CompileRun(source)->BooleanValue(context).FromJust());
|
|
|
|
source = "both_values[2].name() == 'a'";
|
|
CHECK(CompileRun(source)->BooleanValue(context).FromJust());
|
|
|
|
source = "both_values[3].name() == 'b'";
|
|
CHECK(CompileRun(source)->BooleanValue(context).FromJust());
|
|
|
|
source = "both_values[4].name() == 'c'";
|
|
CHECK(CompileRun(source)->BooleanValue(context).FromJust());
|
|
}
|
|
|
|
|
|
TEST(HiddenPrototypePropertyMirror) {
|
|
// Create a V8 environment with debug access.
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
v8::Local<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New(isolate);
|
|
t0->InstanceTemplate()->Set(v8_str(isolate, "x"),
|
|
v8::Number::New(isolate, 0));
|
|
v8::Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
|
|
t1->SetHiddenPrototype(true);
|
|
t1->InstanceTemplate()->Set(v8_str(isolate, "y"),
|
|
v8::Number::New(isolate, 1));
|
|
v8::Local<v8::FunctionTemplate> t2 = v8::FunctionTemplate::New(isolate);
|
|
t2->SetHiddenPrototype(true);
|
|
t2->InstanceTemplate()->Set(v8_str(isolate, "z"),
|
|
v8::Number::New(isolate, 2));
|
|
v8::Local<v8::FunctionTemplate> t3 = v8::FunctionTemplate::New(isolate);
|
|
t3->InstanceTemplate()->Set(v8_str(isolate, "u"),
|
|
v8::Number::New(isolate, 3));
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create object and set them on the global object.
|
|
v8::Local<v8::Object> o0 = t0->GetFunction(context)
|
|
.ToLocalChecked()
|
|
->NewInstance(context)
|
|
.ToLocalChecked();
|
|
CHECK(env->Global()->Set(context, v8_str(isolate, "o0"), o0).FromJust());
|
|
v8::Local<v8::Object> o1 = t1->GetFunction(context)
|
|
.ToLocalChecked()
|
|
->NewInstance(context)
|
|
.ToLocalChecked();
|
|
CHECK(env->Global()->Set(context, v8_str(isolate, "o1"), o1).FromJust());
|
|
v8::Local<v8::Object> o2 = t2->GetFunction(context)
|
|
.ToLocalChecked()
|
|
->NewInstance(context)
|
|
.ToLocalChecked();
|
|
CHECK(env->Global()->Set(context, v8_str(isolate, "o2"), o2).FromJust());
|
|
v8::Local<v8::Object> o3 = t3->GetFunction(context)
|
|
.ToLocalChecked()
|
|
->NewInstance(context)
|
|
.ToLocalChecked();
|
|
CHECK(env->Global()->Set(context, v8_str(isolate, "o3"), o3).FromJust());
|
|
|
|
// Get mirrors for the four objects.
|
|
CompileRun(
|
|
"var o0_mirror = debug.MakeMirror(o0);"
|
|
"var o1_mirror = debug.MakeMirror(o1);"
|
|
"var o2_mirror = debug.MakeMirror(o2);"
|
|
"var o3_mirror = debug.MakeMirror(o3)");
|
|
CHECK(CompileRun("o0_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("o1_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("o2_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("o3_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
|
|
// Check that each object has one property.
|
|
CHECK_EQ(1, CompileRun("o0_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, CompileRun("o1_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, CompileRun("o2_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, CompileRun("o3_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
|
|
// Set o1 as prototype for o0. o1 has the hidden prototype flag so all
|
|
// properties on o1 should be seen on o0.
|
|
CHECK(o0->Set(context, v8_str(isolate, "__proto__"), o1).FromJust());
|
|
CHECK_EQ(2, CompileRun("o0_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(0, CompileRun("o0_mirror.property('x').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, CompileRun("o0_mirror.property('y').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
|
|
// Set o2 as prototype for o0 (it will end up after o1 as o1 has the hidden
|
|
// prototype flag. o2 also has the hidden prototype flag so all properties
|
|
// on o2 should be seen on o0 as well as properties on o1.
|
|
CHECK(o0->Set(context, v8_str(isolate, "__proto__"), o2).FromJust());
|
|
CHECK_EQ(3, CompileRun("o0_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(0, CompileRun("o0_mirror.property('x').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, CompileRun("o0_mirror.property('y').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(2, CompileRun("o0_mirror.property('z').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
|
|
// Set o3 as prototype for o0 (it will end up after o1 and o2 as both o1 and
|
|
// o2 has the hidden prototype flag. o3 does not have the hidden prototype
|
|
// flag so properties on o3 should not be seen on o0 whereas the properties
|
|
// from o1 and o2 should still be seen on o0.
|
|
// Final prototype chain: o0 -> o1 -> o2 -> o3
|
|
// Hidden prototypes: ^^ ^^
|
|
CHECK(o0->Set(context, v8_str(isolate, "__proto__"), o3).FromJust());
|
|
CHECK_EQ(3, CompileRun("o0_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, CompileRun("o3_mirror.propertyNames().length")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(0, CompileRun("o0_mirror.property('x').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(1, CompileRun("o0_mirror.property('y').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK_EQ(2, CompileRun("o0_mirror.property('z').value().value()")
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("o0_mirror.property('u').isUndefined()")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
|
|
// The prototype (__proto__) for o0 should be o3 as o1 and o2 are hidden.
|
|
CHECK(CompileRun("o0_mirror.protoObject().value() == o3_mirror.value()")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
static void ProtperyXNativeGetter(
|
|
v8::Local<v8::String> property,
|
|
const v8::PropertyCallbackInfo<v8::Value>& info) {
|
|
info.GetReturnValue().Set(10);
|
|
}
|
|
|
|
|
|
TEST(NativeGetterPropertyMirror) {
|
|
// Create a V8 environment with debug access.
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
v8::Local<v8::String> name = v8_str(isolate, "x");
|
|
// Create object with named accessor.
|
|
v8::Local<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
|
|
named->SetAccessor(name, &ProtperyXNativeGetter, nullptr,
|
|
v8::Local<v8::Value>(), v8::DEFAULT, v8::None);
|
|
|
|
// Create object with named property getter.
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(isolate, "instance"),
|
|
named->NewInstance(context).ToLocalChecked())
|
|
.FromJust());
|
|
CHECK_EQ(10, CompileRun("instance.x")->Int32Value(context).FromJust());
|
|
|
|
// Get mirror for the object with property getter.
|
|
CompileRun("var instance_mirror = debug.MakeMirror(instance);");
|
|
CHECK(CompileRun("instance_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
|
|
CompileRun("var named_names = instance_mirror.propertyNames();");
|
|
CHECK_EQ(1, CompileRun("named_names.length")->Int32Value(context).FromJust());
|
|
CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue(context).FromJust());
|
|
CHECK(CompileRun("instance_mirror.property('x').value().isNumber()")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("instance_mirror.property('x').value().value() == 10")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
static void ProtperyXNativeGetterThrowingError(
|
|
v8::Local<v8::String> property,
|
|
const v8::PropertyCallbackInfo<v8::Value>& info) {
|
|
CompileRun("throw new Error('Error message');");
|
|
}
|
|
|
|
|
|
TEST(NativeGetterThrowingErrorPropertyMirror) {
|
|
// Create a V8 environment with debug access.
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
v8::Local<v8::String> name = v8_str(isolate, "x");
|
|
// Create object with named accessor.
|
|
v8::Local<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
|
|
named->SetAccessor(name, &ProtperyXNativeGetterThrowingError, nullptr,
|
|
v8::Local<v8::Value>(), v8::DEFAULT, v8::None);
|
|
|
|
// Create object with named property getter.
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(isolate, "instance"),
|
|
named->NewInstance(context).ToLocalChecked())
|
|
.FromJust());
|
|
|
|
// Get mirror for the object with property getter.
|
|
CompileRun("var instance_mirror = debug.MakeMirror(instance);");
|
|
CHECK(CompileRun("instance_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CompileRun("named_names = instance_mirror.propertyNames();");
|
|
CHECK_EQ(1, CompileRun("named_names.length")->Int32Value(context).FromJust());
|
|
CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue(context).FromJust());
|
|
CHECK(CompileRun("instance_mirror.property('x').value().isError()")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
|
|
// Check that the message is that passed to the Error constructor.
|
|
CHECK(
|
|
CompileRun(
|
|
"instance_mirror.property('x').value().message() == 'Error message'")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
// Test that hidden properties object is not returned as an unnamed property
|
|
// among regular properties.
|
|
// See http://crbug.com/26491
|
|
TEST(NoHiddenProperties) {
|
|
// Create a V8 environment with debug access.
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create an object in the global scope.
|
|
const char* source = "var obj = {a: 1};";
|
|
v8::Script::Compile(context, v8_str(isolate, source))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(
|
|
env->Global()->Get(context, v8_str(isolate, "obj")).ToLocalChecked());
|
|
// Set a hidden property on the object.
|
|
obj->SetPrivate(
|
|
env.context(),
|
|
v8::Private::New(isolate, v8_str(isolate, "v8::test-debug::a")),
|
|
v8::Int32::New(isolate, 11))
|
|
.FromJust();
|
|
|
|
// Get mirror for the object with property getter.
|
|
CompileRun("var obj_mirror = debug.MakeMirror(obj);");
|
|
CHECK(CompileRun("obj_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CompileRun("var named_names = obj_mirror.propertyNames();");
|
|
// There should be exactly one property. But there is also an unnamed
|
|
// property whose value is hidden properties dictionary. The latter
|
|
// property should not be in the list of reguar properties.
|
|
CHECK_EQ(1, CompileRun("named_names.length")->Int32Value(context).FromJust());
|
|
CHECK(CompileRun("named_names[0] == 'a'")->BooleanValue(context).FromJust());
|
|
CHECK(CompileRun("obj_mirror.property('a').value().value() == 1")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
|
|
// Object created by t0 will become hidden prototype of object 'obj'.
|
|
v8::Local<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New(isolate);
|
|
t0->InstanceTemplate()->Set(v8_str(isolate, "b"),
|
|
v8::Number::New(isolate, 2));
|
|
t0->SetHiddenPrototype(true);
|
|
v8::Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
|
|
t1->InstanceTemplate()->Set(v8_str(isolate, "c"),
|
|
v8::Number::New(isolate, 3));
|
|
|
|
// Create proto objects, add hidden properties to them and set them on
|
|
// the global object.
|
|
v8::Local<v8::Object> protoObj = t0->GetFunction(context)
|
|
.ToLocalChecked()
|
|
->NewInstance(context)
|
|
.ToLocalChecked();
|
|
protoObj->SetPrivate(
|
|
env.context(),
|
|
v8::Private::New(isolate, v8_str(isolate, "v8::test-debug::b")),
|
|
v8::Int32::New(isolate, 12))
|
|
.FromJust();
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(isolate, "protoObj"), protoObj)
|
|
.FromJust());
|
|
v8::Local<v8::Object> grandProtoObj = t1->GetFunction(context)
|
|
.ToLocalChecked()
|
|
->NewInstance(context)
|
|
.ToLocalChecked();
|
|
grandProtoObj->SetPrivate(env.context(),
|
|
v8::Private::New(
|
|
isolate, v8_str(isolate, "v8::test-debug::c")),
|
|
v8::Int32::New(isolate, 13))
|
|
.FromJust();
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str(isolate, "grandProtoObj"), grandProtoObj)
|
|
.FromJust());
|
|
|
|
// Setting prototypes: obj->protoObj->grandProtoObj
|
|
CHECK(protoObj->Set(context, v8_str(isolate, "__proto__"), grandProtoObj)
|
|
.FromJust());
|
|
CHECK(obj->Set(context, v8_str(isolate, "__proto__"), protoObj).FromJust());
|
|
|
|
// Get mirror for the object with property getter.
|
|
CompileRun("var obj_mirror = debug.MakeMirror(obj);");
|
|
CHECK(CompileRun("obj_mirror instanceof debug.ObjectMirror")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CompileRun("var named_names = obj_mirror.propertyNames();");
|
|
// There should be exactly two properties - one from the object itself and
|
|
// another from its hidden prototype.
|
|
CHECK_EQ(2, CompileRun("named_names.length")->Int32Value(context).FromJust());
|
|
CHECK(CompileRun("named_names.sort(); named_names[0] == 'a' &&"
|
|
"named_names[1] == 'b'")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("obj_mirror.property('a').value().value() == 1")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
CHECK(CompileRun("obj_mirror.property('b').value().value() == 2")
|
|
->BooleanValue(context)
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
TEST(SetDebugEventListenerOnUninitializedVM) {
|
|
v8::HandleScope scope(CcTest::isolate());
|
|
EnableDebugger(CcTest::isolate());
|
|
}
|
|
|
|
// Source for a JavaScript function which returns the data parameter of a
|
|
// function called in the context of the debugger. If no data parameter is
|
|
// passed it throws an exception.
|
|
static const char* debugger_call_with_data_source =
|
|
"function debugger_call_with_data(exec_state, data) {"
|
|
" if (data) return data;"
|
|
" throw 'No data!'"
|
|
"}";
|
|
v8::Local<v8::Function> debugger_call_with_data;
|
|
|
|
|
|
// Source for a JavaScript function which returns the data parameter of a
|
|
// function called in the context of the debugger. If no data parameter is
|
|
// passed it throws an exception.
|
|
static const char* debugger_call_with_closure_source =
|
|
"var x = 3;"
|
|
"(function (exec_state) {"
|
|
" if (exec_state.y) return x - 1;"
|
|
" exec_state.y = x;"
|
|
" return exec_state.y"
|
|
"})";
|
|
v8::Local<v8::Function> debugger_call_with_closure;
|
|
|
|
// Function to retrieve the number of JavaScript frames by calling a JavaScript
|
|
// in the debugger.
|
|
static void CheckFrameCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
|
|
CHECK(v8::debug::Call(context, frame_count).ToLocalChecked()->IsNumber());
|
|
CHECK_EQ(args[0]->Int32Value(context).FromJust(),
|
|
v8::debug::Call(context, frame_count)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
// Function to retrieve the source line of the top JavaScript frame by calling a
|
|
// JavaScript function in the debugger.
|
|
static void CheckSourceLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
|
|
CHECK(
|
|
v8::debug::Call(context, frame_source_line).ToLocalChecked()->IsNumber());
|
|
CHECK_EQ(args[0]->Int32Value(context).FromJust(),
|
|
v8::debug::Call(context, frame_source_line)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
// Function to test passing an additional parameter to a JavaScript function
|
|
// called in the debugger. It also tests that functions called in the debugger
|
|
// can throw exceptions.
|
|
static void CheckDataParameter(
|
|
const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::Local<v8::String> data = v8_str(args.GetIsolate(), "Test");
|
|
v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
|
|
CHECK(v8::debug::Call(context, debugger_call_with_data, data)
|
|
.ToLocalChecked()
|
|
->IsString());
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
v8::TryCatch catcher(args.GetIsolate());
|
|
CHECK(v8::debug::Call(context, debugger_call_with_data).IsEmpty());
|
|
CHECK(catcher.HasCaught());
|
|
CHECK(catcher.Exception()->IsString());
|
|
}
|
|
}
|
|
|
|
|
|
// Function to test using a JavaScript with closure in the debugger.
|
|
static void CheckClosure(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
|
|
CHECK(v8::debug::Call(context, debugger_call_with_closure)
|
|
.ToLocalChecked()
|
|
->IsNumber());
|
|
CHECK_EQ(3, v8::debug::Call(context, debugger_call_with_closure)
|
|
.ToLocalChecked()
|
|
->Int32Value(context)
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
// Test functions called through the debugger.
|
|
TEST(CallFunctionInDebugger) {
|
|
// Create and enter a context with the functions CheckFrameCount,
|
|
// CheckSourceLine and CheckDataParameter installed.
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
v8::HandleScope scope(isolate);
|
|
v8::Local<v8::ObjectTemplate> global_template =
|
|
v8::ObjectTemplate::New(isolate);
|
|
global_template->Set(v8_str(isolate, "CheckFrameCount"),
|
|
v8::FunctionTemplate::New(isolate, CheckFrameCount));
|
|
global_template->Set(v8_str(isolate, "CheckSourceLine"),
|
|
v8::FunctionTemplate::New(isolate, CheckSourceLine));
|
|
global_template->Set(v8_str(isolate, "CheckDataParameter"),
|
|
v8::FunctionTemplate::New(isolate, CheckDataParameter));
|
|
global_template->Set(v8_str(isolate, "CheckClosure"),
|
|
v8::FunctionTemplate::New(isolate, CheckClosure));
|
|
v8::Local<v8::Context> context =
|
|
v8::Context::New(isolate, nullptr, global_template);
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
// Compile a function for checking the number of JavaScript frames.
|
|
v8::Script::Compile(context, v8_str(isolate, frame_count_source))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
frame_count = v8::Local<v8::Function>::Cast(
|
|
context->Global()
|
|
->Get(context, v8_str(isolate, "frame_count"))
|
|
.ToLocalChecked());
|
|
|
|
// Compile a function for returning the source line for the top frame.
|
|
v8::Script::Compile(context, v8_str(isolate, frame_source_line_source))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
frame_source_line = v8::Local<v8::Function>::Cast(
|
|
context->Global()
|
|
->Get(context, v8_str(isolate, "frame_source_line"))
|
|
.ToLocalChecked());
|
|
|
|
// Compile a function returning the data parameter.
|
|
v8::Script::Compile(context, v8_str(isolate, debugger_call_with_data_source))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
debugger_call_with_data = v8::Local<v8::Function>::Cast(
|
|
context->Global()
|
|
->Get(context, v8_str(isolate, "debugger_call_with_data"))
|
|
.ToLocalChecked());
|
|
|
|
// Compile a function capturing closure.
|
|
debugger_call_with_closure = v8::Local<v8::Function>::Cast(
|
|
v8::Script::Compile(context,
|
|
v8_str(isolate, debugger_call_with_closure_source))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked());
|
|
|
|
// Calling a function through the debugger returns 0 frames if there are
|
|
// no JavaScript frames.
|
|
CHECK(v8::Integer::New(isolate, 0)
|
|
->Equals(context,
|
|
v8::debug::Call(context, frame_count).ToLocalChecked())
|
|
.FromJust());
|
|
|
|
// Test that the number of frames can be retrieved.
|
|
v8::Script::Compile(context, v8_str(isolate, "CheckFrameCount(1)"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::Script::Compile(context, v8_str(isolate,
|
|
"function f() {"
|
|
" CheckFrameCount(2);"
|
|
"}; f()"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
|
|
// Test that the source line can be retrieved.
|
|
v8::Script::Compile(context, v8_str(isolate, "CheckSourceLine(0)"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::Script::Compile(context, v8_str(isolate,
|
|
"function f() {\n"
|
|
" CheckSourceLine(1)\n"
|
|
" CheckSourceLine(2)\n"
|
|
" CheckSourceLine(3)\n"
|
|
"}; f()"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
|
|
// Test that a parameter can be passed to a function called in the debugger.
|
|
v8::Script::Compile(context, v8_str(isolate, "CheckDataParameter()"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
|
|
// Test that a function with closure can be run in the debugger.
|
|
v8::Script::Compile(context, v8_str(isolate, "CheckClosure()"))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
|
|
// Test that the source line is correct when there is a line offset.
|
|
v8::ScriptOrigin origin(v8_str(isolate, "test"),
|
|
v8::Integer::New(isolate, 7));
|
|
v8::Script::Compile(context, v8_str(isolate, "CheckSourceLine(7)"), &origin)
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::Script::Compile(context, v8_str(isolate,
|
|
"function f() {\n"
|
|
" CheckSourceLine(8)\n"
|
|
" CheckSourceLine(9)\n"
|
|
" CheckSourceLine(10)\n"
|
|
"}; f()"),
|
|
&origin)
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
}
|
|
|
|
|
|
// Test that clearing the debug event listener actually clears all break points
|
|
// and related information.
|
|
TEST(DebuggerUnload) {
|
|
DebugLocalContext env;
|
|
|
|
// Check debugger is unloaded before it is used.
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Set a debug event listener.
|
|
break_point_hit_count = 0;
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
v8::Local<v8::Context> context = env.context();
|
|
{
|
|
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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
int event_listener_hit_count = 0;
|
|
|
|
// Debugger event listener which clears itself while active.
|
|
static void EventListenerClearingItself(
|
|
const v8::Debug::EventDetails& details) {
|
|
event_listener_hit_count++;
|
|
|
|
// Clear debug event listener.
|
|
SetDebugEventListener(details.GetIsolate(), nullptr);
|
|
}
|
|
|
|
|
|
// Test clearing the debug message handler while processing a debug event.
|
|
TEST(DebuggerClearEventListenerWhileActive) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Check debugger is unloaded before it is used.
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Set a debug event listener.
|
|
SetDebugEventListener(env->GetIsolate(), EventListenerClearingItself);
|
|
|
|
// Run code to throw an uncaught exception. This should trigger the listener.
|
|
CompileRun("throw 1");
|
|
|
|
// The event listener should have been called.
|
|
CHECK_EQ(1, event_listener_hit_count);
|
|
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// 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; }
|
|
virtual ~EmptyExternalStringResource() {}
|
|
virtual size_t length() const { return empty_.length(); }
|
|
virtual const uint16_t* data() const { return empty_.start(); }
|
|
private:
|
|
::v8::internal::EmbeddedVector<uint16_t, 1> empty_;
|
|
};
|
|
|
|
TEST(DebugScriptLineEndsAreAscending) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
// 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.context(), script, &origin1).ToLocalChecked();
|
|
USE(script1);
|
|
|
|
Handle<v8::internal::FixedArray> instances;
|
|
{
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
v8::internal::DebugScope debug_scope(debug);
|
|
CHECK(!debug_scope.failed());
|
|
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)));
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Test script break points set on lines.
|
|
TEST(ScriptNameAndData) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
env.ExposeDebug();
|
|
|
|
// Create functions for retrieving script name and data for the function on
|
|
// the top frame when hitting a break point.
|
|
frame_script_name = CompileFunction(&env,
|
|
frame_script_name_source,
|
|
"frame_script_name");
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Test function source.
|
|
v8::Local<v8::String> script = v8_str(env->GetIsolate(),
|
|
"function f() {\n"
|
|
" debugger;\n"
|
|
"}\n");
|
|
|
|
v8::ScriptOrigin origin1 =
|
|
v8::ScriptOrigin(v8_str(env->GetIsolate(), "name"));
|
|
v8::Local<v8::Script> script1 =
|
|
v8::Script::Compile(context, script, &origin1).ToLocalChecked();
|
|
script1->Run(context).ToLocalChecked();
|
|
v8::Local<v8::Function> f;
|
|
f = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "f"))
|
|
.ToLocalChecked());
|
|
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CHECK_EQ(0, strcmp("name", last_script_name_hit));
|
|
|
|
// Compile the same script again without setting data. As the compilation
|
|
// cache is disabled when debugging expect the data to be missing.
|
|
v8::Script::Compile(context, script, &origin1)
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
f = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "f"))
|
|
.ToLocalChecked());
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, break_point_hit_count);
|
|
CHECK_EQ(0, strcmp("name", last_script_name_hit));
|
|
|
|
v8::Local<v8::String> data_obj_source =
|
|
v8_str(env->GetIsolate(),
|
|
"({ a: 'abc',\n"
|
|
" b: 123,\n"
|
|
" toString: function() { return this.a + ' ' + this.b; }\n"
|
|
"})\n");
|
|
v8::Script::Compile(context, data_obj_source)
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
v8::ScriptOrigin origin2 =
|
|
v8::ScriptOrigin(v8_str(env->GetIsolate(), "new name"));
|
|
v8::Local<v8::Script> script2 =
|
|
v8::Script::Compile(context, script, &origin2).ToLocalChecked();
|
|
script2->Run(context).ToLocalChecked();
|
|
f = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "f"))
|
|
.ToLocalChecked());
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(3, break_point_hit_count);
|
|
CHECK_EQ(0, strcmp("new name", last_script_name_hit));
|
|
|
|
v8::Local<v8::Script> script3 =
|
|
v8::Script::Compile(context, script, &origin2).ToLocalChecked();
|
|
script3->Run(context).ToLocalChecked();
|
|
f = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "f"))
|
|
.ToLocalChecked());
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
}
|
|
|
|
|
|
static v8::Local<v8::Context> expected_context;
|
|
static v8::Local<v8::Value> expected_context_data;
|
|
|
|
|
|
// Check that the expected context is the one generating the debug event.
|
|
static void ContextCheckEventListener(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
CHECK(event_details.GetEventContext() == expected_context);
|
|
CHECK(event_details.GetEventContext()->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);
|
|
|
|
SetDebugEventListener(isolate, ContextCheckEventListener);
|
|
|
|
// 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);
|
|
|
|
SetDebugEventListener(isolate, nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
// Debug event listener which issues a debug break when it hits a break event.
|
|
static int event_listener_break_hit_count = 0;
|
|
static void DebugBreakEventListener(const v8::Debug::EventDetails& details) {
|
|
// Schedule a debug break for break events.
|
|
if (details.GetEvent() == v8::Break) {
|
|
event_listener_break_hit_count++;
|
|
if (event_listener_break_hit_count == 1) {
|
|
v8::debug::DebugBreak(details.GetIsolate());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that a debug break can be scheduled while in a event listener.
|
|
TEST(DebugBreakInEventListener) {
|
|
i::FLAG_turbo_inlining = false; // Make sure g is not inlined into f.
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugBreakEventListener);
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Test functions.
|
|
const char* script = "function f() { debugger; g(); } function g() { }";
|
|
CompileRun(script);
|
|
v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "f"))
|
|
.ToLocalChecked());
|
|
v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "g"))
|
|
.ToLocalChecked());
|
|
|
|
// Call f then g. The debugger statement in f will cause a break which will
|
|
// cause another break.
|
|
f->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, event_listener_break_hit_count);
|
|
// Calling g will not cause any additional breaks.
|
|
g->Call(context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(2, event_listener_break_hit_count);
|
|
}
|
|
|
|
|
|
#ifndef V8_INTERPRETED_REGEXP
|
|
// Debug event handler which gets the function on the top frame and schedules a
|
|
// break a number of times.
|
|
static void DebugEventDebugBreak(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
if (event == v8::Break) {
|
|
break_point_hit_count++;
|
|
|
|
// Get the name of the top frame function.
|
|
if (!frame_function_name.IsEmpty()) {
|
|
// Get the name of the function.
|
|
const int argc = 2;
|
|
v8::Local<v8::Value> argv[argc] = {
|
|
exec_state, v8::Integer::New(CcTest::isolate(), 0)};
|
|
v8::Local<v8::Value> result =
|
|
frame_function_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
if (result->IsUndefined()) {
|
|
last_function_hit[0] = '\0';
|
|
} else {
|
|
CHECK(result->IsString());
|
|
v8::Local<v8::String> function_name(
|
|
result->ToString(context).ToLocalChecked());
|
|
function_name->WriteUtf8(last_function_hit);
|
|
}
|
|
}
|
|
|
|
// Keep forcing breaks.
|
|
if (break_point_hit_count < 20) {
|
|
v8::debug::DebugBreak(CcTest::isolate());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(RegExpDebugBreak) {
|
|
// This test only applies to native regexps.
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
// Create a function for checking the function when hitting a break point.
|
|
frame_function_name = CompileFunction(&env,
|
|
frame_function_name_source,
|
|
"frame_function_name");
|
|
|
|
// Test RegExp which matches white spaces and comments at the beginning of a
|
|
// source line.
|
|
const char* script =
|
|
"var sourceLineBeginningSkip = /^(?:[ \\v\\h]*(?:\\/\\*.*?\\*\\/)*)*/;\n"
|
|
"function f(s) { return s.match(sourceLineBeginningSkip)[0].length; }";
|
|
|
|
v8::Local<v8::Function> f = CompileFunction(env->GetIsolate(), script, "f");
|
|
const int argc = 1;
|
|
v8::Local<v8::Value> argv[argc] = {
|
|
v8_str(env->GetIsolate(), " /* xxx */ a=0;")};
|
|
v8::Local<v8::Value> result =
|
|
f->Call(context, env->Global(), argc, argv).ToLocalChecked();
|
|
CHECK_EQ(12, result->Int32Value(context).FromJust());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventDebugBreak);
|
|
v8::debug::DebugBreak(env->GetIsolate());
|
|
result = f->Call(context, env->Global(), argc, argv).ToLocalChecked();
|
|
|
|
// Check that there was only one break event. Matching RegExp should not
|
|
// cause Break events.
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
CHECK_EQ(0, strcmp("f", last_function_hit));
|
|
}
|
|
#endif // V8_INTERPRETED_REGEXP
|
|
|
|
// 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);
|
|
|
|
SetDebugEventListener(CcTest::isolate(), ContextCheckEventListener);
|
|
|
|
// 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();
|
|
}
|
|
|
|
SetDebugEventListener(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 the after compile events.
|
|
int after_compile_event_count = 0;
|
|
static void AfterCompileEventListener(const v8::Debug::EventDetails& details) {
|
|
// Count the number of scripts collected.
|
|
if (details.GetEvent() == v8::AfterCompile) {
|
|
after_compile_event_count++;
|
|
}
|
|
}
|
|
|
|
|
|
// Tests that after compile event is sent as many times as there are scripts
|
|
// compiled.
|
|
TEST(AfterCompileEventWhenEventListenerIsReset) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
const char* script = "var a=1";
|
|
|
|
SetDebugEventListener(env->GetIsolate(), AfterCompileEventListener);
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), AfterCompileEventListener);
|
|
v8::debug::DebugBreak(env->GetIsolate());
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
|
|
// Setting listener to nullptr should cause debugger unload.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Compilation cache should be disabled when debugger is active.
|
|
CHECK_EQ(2, after_compile_event_count);
|
|
}
|
|
|
|
|
|
// Syntax error event handler which counts a number of events.
|
|
int compile_error_event_count = 0;
|
|
|
|
static void CompileErrorEventCounterClear() {
|
|
compile_error_event_count = 0;
|
|
}
|
|
|
|
static void CompileErrorEventCounter(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
|
|
if (event == v8::CompileError) {
|
|
compile_error_event_count++;
|
|
}
|
|
}
|
|
|
|
|
|
// Tests that syntax error event is sent as many times as there are scripts
|
|
// with syntax error compiled.
|
|
TEST(SyntaxErrorEventOnSyntaxException) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// For this test, we want to break on uncaught exceptions:
|
|
ChangeBreakOnException(false, true);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), CompileErrorEventCounter);
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
CompileErrorEventCounterClear();
|
|
|
|
// Check initial state.
|
|
CHECK_EQ(0, compile_error_event_count);
|
|
|
|
// Throws SyntaxError: Unexpected end of input
|
|
CHECK(
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), "+++")).IsEmpty());
|
|
CHECK_EQ(1, compile_error_event_count);
|
|
|
|
CHECK(v8::Script::Compile(context, v8_str(env->GetIsolate(), "/sel\\/: \\"))
|
|
.IsEmpty());
|
|
CHECK_EQ(2, compile_error_event_count);
|
|
|
|
v8::Local<v8::Script> script =
|
|
v8::Script::Compile(context,
|
|
v8_str(env->GetIsolate(), "JSON.parse('1234:')"))
|
|
.ToLocalChecked();
|
|
CHECK_EQ(2, compile_error_event_count);
|
|
CHECK(script->Run(context).IsEmpty());
|
|
CHECK_EQ(3, compile_error_event_count);
|
|
|
|
v8::Script::Compile(context,
|
|
v8_str(env->GetIsolate(), "new RegExp('/\\/\\\\');"))
|
|
.ToLocalChecked();
|
|
CHECK_EQ(3, compile_error_event_count);
|
|
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), "throw 1;"))
|
|
.ToLocalChecked();
|
|
CHECK_EQ(3, compile_error_event_count);
|
|
}
|
|
|
|
// Tests that break event is sent when event listener is reset.
|
|
TEST(BreakEventWhenEventListenerIsReset) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
const char* script = "function f() {};";
|
|
|
|
SetDebugEventListener(env->GetIsolate(), AfterCompileEventListener);
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), AfterCompileEventListener);
|
|
v8::debug::DebugBreak(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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
// Compilation cache should be disabled when debugger is active.
|
|
CHECK_EQ(1, after_compile_event_count);
|
|
}
|
|
|
|
|
|
static int exception_event_count = 0;
|
|
static void ExceptionEventListener(const v8::Debug::EventDetails& details) {
|
|
if (details.GetEvent() == v8::Exception) exception_event_count++;
|
|
}
|
|
|
|
// Tests that exception event is sent when event listener is reset.
|
|
TEST(ExceptionEventWhenEventListenerIsReset) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
v8::Local<v8::Context> context = env.context();
|
|
// For this test, we want to break on uncaught exceptions:
|
|
ChangeBreakOnException(false, true);
|
|
|
|
exception_event_count = 0;
|
|
const char* script = "function f() {throw new Error()};";
|
|
|
|
SetDebugEventListener(env->GetIsolate(), AfterCompileEventListener);
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), ExceptionEventListener);
|
|
v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
|
|
env->Global()
|
|
->Get(context, v8_str(env->GetIsolate(), "f"))
|
|
.ToLocalChecked());
|
|
CHECK(f->Call(context, env->Global(), 0, nullptr).IsEmpty());
|
|
|
|
// Setting event listener to nullptr should cause debugger unload.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
|
|
CHECK_EQ(1, exception_event_count);
|
|
}
|
|
|
|
|
|
static void BreakEventListener(const v8::Debug::EventDetails& details) {
|
|
if (details.GetEvent() == v8::Break) break_point_hit_count++;
|
|
}
|
|
|
|
|
|
// Test that if DebugBreak is forced it is ignored when code from
|
|
// debug-delay.js is executed.
|
|
TEST(NoDebugBreakInAfterCompileEventListener) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
SetDebugEventListener(env->GetIsolate(), BreakEventListener);
|
|
|
|
// Set the debug break flag.
|
|
v8::debug::DebugBreak(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::DebugBreak(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.
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
// Test that the debug break flag works with function.apply.
|
|
TEST(DebugBreakFunctionApply) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
// 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.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakMax);
|
|
|
|
// Set the debug break flag before calling the code using function.apply.
|
|
v8::debug::DebugBreak(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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
v8::Local<v8::Context> debugee_context;
|
|
v8::Local<v8::Context> debugger_context;
|
|
|
|
|
|
// Property getter that checks that current and calling contexts
|
|
// are both the debugee contexts.
|
|
static void NamedGetterWithCallingContextCheck(
|
|
v8::Local<v8::String> name,
|
|
const v8::PropertyCallbackInfo<v8::Value>& info) {
|
|
CHECK_EQ(0, strcmp(*v8::String::Utf8Value(info.GetIsolate(), name), "a"));
|
|
v8::Local<v8::Context> current = info.GetIsolate()->GetCurrentContext();
|
|
CHECK(current == debugee_context);
|
|
CHECK(current != debugger_context);
|
|
info.GetReturnValue().Set(1);
|
|
}
|
|
|
|
|
|
// Debug event listener that checks if the first argument of a function is
|
|
// an object with property 'a' == 1. If the property has custom accessor
|
|
// this handler will eventually invoke it.
|
|
static void DebugEventGetAtgumentPropertyValue(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
if (event == v8::Break) {
|
|
break_point_hit_count++;
|
|
CHECK(debugger_context == CcTest::isolate()->GetCurrentContext());
|
|
v8::Local<v8::Function> func = v8::Local<v8::Function>::Cast(CompileRun(
|
|
"(function(exec_state) {\n"
|
|
" return (exec_state.frame(0).argumentValue(0).property('a').\n"
|
|
" value().value() == 1);\n"
|
|
"})"));
|
|
const int argc = 1;
|
|
v8::Local<v8::Value> argv[argc] = {exec_state};
|
|
v8::Local<v8::Value> result =
|
|
func->Call(debugger_context, exec_state, argc, argv).ToLocalChecked();
|
|
CHECK(result->IsTrue());
|
|
}
|
|
}
|
|
|
|
|
|
TEST(CallingContextIsNotDebugContext) {
|
|
v8::internal::Debug* debug = CcTest::i_isolate()->debug();
|
|
// Create and enter a debugee context.
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
env.ExposeDebug();
|
|
|
|
// Save handles to the debugger and debugee contexts to be used in
|
|
// NamedGetterWithCallingContextCheck.
|
|
debugee_context = env.context();
|
|
debugger_context = v8::Utils::ToLocal(debug->debug_context());
|
|
|
|
// Create object with 'a' property accessor.
|
|
v8::Local<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
|
|
named->SetAccessor(v8_str(isolate, "a"), NamedGetterWithCallingContextCheck);
|
|
CHECK(env->Global()
|
|
->Set(debugee_context, v8_str(isolate, "obj"),
|
|
named->NewInstance(debugee_context).ToLocalChecked())
|
|
.FromJust());
|
|
|
|
// Register the debug event listener
|
|
SetDebugEventListener(isolate, DebugEventGetAtgumentPropertyValue);
|
|
|
|
// Create a function that invokes debugger.
|
|
v8::Local<v8::Function> foo = CompileFunction(
|
|
&env,
|
|
"function bar(x) { debugger; }"
|
|
"function foo(){ bar(obj); }",
|
|
"foo");
|
|
|
|
break_point_hit_count = 0;
|
|
foo->Call(debugee_context, env->Global(), 0, nullptr).ToLocalChecked();
|
|
CHECK_EQ(1, break_point_hit_count);
|
|
|
|
SetDebugEventListener(isolate, nullptr);
|
|
debugee_context = v8::Local<v8::Context>();
|
|
debugger_context = v8::Local<v8::Context>();
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
static v8::Local<v8::Value> expected_callback_data;
|
|
static void DebugEventContextChecker(const v8::Debug::EventDetails& details) {
|
|
CHECK(details.GetEventContext() == expected_context);
|
|
CHECK(expected_callback_data->Equals(details.GetEventContext(),
|
|
details.GetCallbackData())
|
|
.FromJust());
|
|
}
|
|
|
|
|
|
// Check that event details contain context where debug event occurred.
|
|
TEST(DebugEventContext) {
|
|
v8::Isolate* isolate = CcTest::isolate();
|
|
v8::HandleScope scope(isolate);
|
|
expected_context = v8::Context::New(isolate);
|
|
expected_callback_data = v8::Int32::New(isolate, 2010);
|
|
SetDebugEventListener(isolate, DebugEventContextChecker,
|
|
expected_callback_data);
|
|
v8::Context::Scope context_scope(expected_context);
|
|
v8::Script::Compile(expected_context,
|
|
v8_str(isolate, "(function(){debugger;})();"))
|
|
.ToLocalChecked()
|
|
->Run(expected_context)
|
|
.ToLocalChecked();
|
|
expected_context.Clear();
|
|
SetDebugEventListener(isolate, nullptr);
|
|
expected_context_data = v8::Local<v8::Value>();
|
|
CheckDebuggerUnloaded();
|
|
}
|
|
|
|
|
|
static bool debug_event_break_deoptimize_done = false;
|
|
|
|
static void DebugEventBreakDeoptimize(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
if (event == v8::Break) {
|
|
if (!frame_function_name.IsEmpty()) {
|
|
// Get the name of the function.
|
|
const int argc = 2;
|
|
v8::Local<v8::Value> argv[argc] = {
|
|
exec_state, v8::Integer::New(CcTest::isolate(), 0)};
|
|
v8::Local<v8::Value> result =
|
|
frame_function_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
if (!result->IsUndefined()) {
|
|
char fn[80];
|
|
CHECK(result->IsString());
|
|
v8::Local<v8::String> function_name(
|
|
result->ToString(context).ToLocalChecked());
|
|
function_name->WriteUtf8(fn);
|
|
if (strcmp(fn, "bar") == 0) {
|
|
i::Deoptimizer::DeoptimizeAll(CcTest::i_isolate());
|
|
debug_event_break_deoptimize_done = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
v8::debug::DebugBreak(CcTest::isolate());
|
|
}
|
|
}
|
|
|
|
|
|
// Test deoptimization when execution is broken using the debug break stack
|
|
// check interrupt.
|
|
TEST(DeoptimizeDuringDebugBreak) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
env.ExposeDebug();
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
// Create a function for checking the function when hitting a break point.
|
|
frame_function_name = CompileFunction(&env,
|
|
frame_function_name_source,
|
|
"frame_function_name");
|
|
|
|
// Set a debug event listener which will keep interrupting execution until
|
|
// debug break. When inside function bar it will deoptimize all functions.
|
|
// This tests lazy deoptimization bailout for the stack check, as the first
|
|
// time in function bar when using debug break and no break points will be at
|
|
// the initial stack check.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakDeoptimize);
|
|
|
|
// Compile and run function bar which will optimize it for some flag settings.
|
|
v8::Local<v8::Function> f = CompileFunction(&env, "function bar(){}", "bar");
|
|
f->Call(context, v8::Undefined(env->GetIsolate()), 0, nullptr)
|
|
.ToLocalChecked();
|
|
|
|
// Set debug break and call bar again.
|
|
v8::debug::DebugBreak(env->GetIsolate());
|
|
f->Call(context, v8::Undefined(env->GetIsolate()), 0, nullptr)
|
|
.ToLocalChecked();
|
|
|
|
CHECK(debug_event_break_deoptimize_done);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
}
|
|
|
|
|
|
static void DebugEventBreakWithOptimizedStack(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::Isolate* isolate = event_details.GetEventContext()->GetIsolate();
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Object> exec_state = event_details.GetExecutionState();
|
|
v8::Local<v8::Context> context = isolate->GetCurrentContext();
|
|
if (event == v8::Break) {
|
|
if (!frame_function_name.IsEmpty()) {
|
|
for (int i = 0; i < 2; i++) {
|
|
const int argc = 2;
|
|
v8::Local<v8::Value> argv[argc] = {exec_state,
|
|
v8::Integer::New(isolate, i)};
|
|
// Get the name of the function in frame i.
|
|
v8::Local<v8::Value> result =
|
|
frame_function_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsString());
|
|
v8::Local<v8::String> function_name(
|
|
result->ToString(context).ToLocalChecked());
|
|
CHECK(
|
|
function_name->Equals(context, v8_str(isolate, "loop")).FromJust());
|
|
// Get the name of the first argument in frame i.
|
|
result = frame_argument_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsString());
|
|
v8::Local<v8::String> argument_name(
|
|
result->ToString(context).ToLocalChecked());
|
|
CHECK(argument_name->Equals(context, v8_str(isolate, "count"))
|
|
.FromJust());
|
|
// Get the value of the first argument in frame i. If the
|
|
// function is optimized the value will be undefined, otherwise
|
|
// the value will be '1 - i'.
|
|
//
|
|
// TODO(3141533): We should be able to get the real value for
|
|
// optimized frames.
|
|
result = frame_argument_value->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsUndefined() ||
|
|
(result->Int32Value(context).FromJust() == 1 - i));
|
|
// Get the name of the first local variable.
|
|
result = frame_local_name->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsString());
|
|
v8::Local<v8::String> local_name(
|
|
result->ToString(context).ToLocalChecked());
|
|
CHECK(local_name->Equals(context, v8_str(isolate, "local")).FromJust());
|
|
// Get the value of the first local variable. If the function
|
|
// is optimized the value will be undefined, otherwise it will
|
|
// be 42.
|
|
//
|
|
// TODO(3141533): We should be able to get the real value for
|
|
// optimized frames.
|
|
result = frame_local_value->Call(context, exec_state, argc, argv)
|
|
.ToLocalChecked();
|
|
CHECK(result->IsUndefined() ||
|
|
(result->Int32Value(context).FromJust() == 42));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void ScheduleBreak(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
SetDebugEventListener(args.GetIsolate(), DebugEventBreakWithOptimizedStack);
|
|
v8::debug::DebugBreak(args.GetIsolate());
|
|
}
|
|
|
|
|
|
TEST(DebugBreakStackInspection) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
|
|
frame_function_name =
|
|
CompileFunction(&env, frame_function_name_source, "frame_function_name");
|
|
frame_argument_name =
|
|
CompileFunction(&env, frame_argument_name_source, "frame_argument_name");
|
|
frame_argument_value = CompileFunction(&env,
|
|
frame_argument_value_source,
|
|
"frame_argument_value");
|
|
frame_local_name =
|
|
CompileFunction(&env, frame_local_name_source, "frame_local_name");
|
|
frame_local_value =
|
|
CompileFunction(&env, frame_local_value_source, "frame_local_value");
|
|
|
|
v8::Local<v8::FunctionTemplate> schedule_break_template =
|
|
v8::FunctionTemplate::New(env->GetIsolate(), ScheduleBreak);
|
|
v8::Local<v8::Function> schedule_break =
|
|
schedule_break_template->GetFunction(context).ToLocalChecked();
|
|
CHECK(env->Global()
|
|
->Set(context, v8_str("scheduleBreak"), schedule_break)
|
|
.FromJust());
|
|
|
|
const char* src =
|
|
"function loop(count) {"
|
|
" var local = 42;"
|
|
" if (count < 1) { scheduleBreak(); loop(count + 1); }"
|
|
"}"
|
|
"loop(0);";
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), src))
|
|
.ToLocalChecked()
|
|
->Run(context)
|
|
.ToLocalChecked();
|
|
}
|
|
|
|
|
|
// 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.
|
|
|
|
EmbeddedVector<char, 1024> buffer;
|
|
SNPrintF(buffer, "function f() {%s%s%s}", loop_head, loop_bodies[i],
|
|
loop_tail);
|
|
|
|
i::PrintF("%s\n", buffer.start());
|
|
|
|
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.start());
|
|
|
|
// Set the debug break to enter the debugger as soon as possible.
|
|
v8::debug::DebugBreak(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) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
// Register a debug event listener which sets the break flag and counts.
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventBreakMax);
|
|
|
|
CompileRun(
|
|
"var a = 1;\n"
|
|
"function g() { }\n"
|
|
"function h() { }");
|
|
|
|
TestDebugBreakInLoop(loop_header, loop_bodies, loop_footer);
|
|
|
|
// Get rid of the debug event listener.
|
|
SetDebugEventListener(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, "}");
|
|
}
|
|
|
|
|
|
v8::Local<v8::Script> inline_script;
|
|
|
|
static void DebugBreakInlineListener(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
|
|
if (event != v8::Break) return;
|
|
|
|
int expected_frame_count = 4;
|
|
int expected_line_number[] = {1, 4, 7, 12};
|
|
|
|
i::Handle<i::Object> compiled_script = v8::Utils::OpenHandle(*inline_script);
|
|
i::Handle<i::Script> source_script = i::Handle<i::Script>(i::Script::cast(
|
|
i::JSFunction::cast(*compiled_script)->shared()->script()));
|
|
|
|
int break_id = CcTest::i_isolate()->debug()->break_id();
|
|
char script[128];
|
|
i::Vector<char> script_vector(script, sizeof(script));
|
|
SNPrintF(script_vector, "%%GetFrameCount(%d)", break_id);
|
|
v8::Local<v8::Value> result = CompileRun(script);
|
|
|
|
int frame_count = result->Int32Value(context).FromJust();
|
|
CHECK_EQ(expected_frame_count, frame_count);
|
|
|
|
for (int i = 0; i < frame_count; i++) {
|
|
// The 6. element in the returned array of GetFrameDetails contains the
|
|
// source position of that frame.
|
|
SNPrintF(script_vector, "%%GetFrameDetails(%d, %d)[6]", break_id, i);
|
|
v8::Local<v8::Value> result = CompileRun(script);
|
|
CHECK_EQ(expected_line_number[i],
|
|
i::Script::GetLineNumber(source_script,
|
|
result->Int32Value(context).FromJust()));
|
|
}
|
|
SetDebugEventListener(CcTest::isolate(), nullptr);
|
|
CcTest::isolate()->TerminateExecution();
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInline) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::Local<v8::Context> context = env.context();
|
|
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"
|
|
"g(false); \n"
|
|
"g(false); \n"
|
|
"%OptimizeFunctionOnNextCall(g); \n"
|
|
"g(true);";
|
|
SetDebugEventListener(env->GetIsolate(), DebugBreakInlineListener);
|
|
inline_script =
|
|
v8::Script::Compile(context, v8_str(env->GetIsolate(), source))
|
|
.ToLocalChecked();
|
|
inline_script->Run(context).ToLocalChecked();
|
|
}
|
|
|
|
|
|
static void DebugEventStepNext(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
if (event == v8::Break) {
|
|
PrepareStep(StepNext);
|
|
}
|
|
}
|
|
|
|
|
|
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.
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
SetDebugEventListener(env->GetIsolate(), DebugEventStepNext);
|
|
|
|
// 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);
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
}
|
|
|
|
|
|
// Import from test-heap.cc
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace heap {
|
|
int CountNativeContexts();
|
|
} // namespace heap
|
|
} // namespace internal
|
|
} // namespace v8
|
|
|
|
static void NopListener(const v8::Debug::EventDetails& event_details) {
|
|
}
|
|
|
|
|
|
TEST(DebuggerCreatesContextIffActive) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
CHECK_EQ(1, v8::internal::heap::CountNativeContexts());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CompileRun("debugger;");
|
|
CHECK_EQ(1, v8::internal::heap::CountNativeContexts());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), NopListener);
|
|
CompileRun("debugger;");
|
|
CHECK_EQ(2, v8::internal::heap::CountNativeContexts());
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
}
|
|
|
|
|
|
TEST(LiveEditEnabled) {
|
|
v8::internal::FLAG_allow_natives_syntax = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::debug::SetLiveEditEnabled(env->GetIsolate(), true);
|
|
CompileRun("%LiveEditCompareStrings('', '')");
|
|
}
|
|
|
|
|
|
TEST(LiveEditDisabled) {
|
|
v8::internal::FLAG_allow_natives_syntax = true;
|
|
LocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
v8::debug::SetLiveEditEnabled(env->GetIsolate(), false);
|
|
CompileRun("%LiveEditCompareStrings('', '')");
|
|
}
|
|
|
|
|
|
static void DebugBreakStackTraceListener(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::StackTrace::CurrentStackTrace(CcTest::isolate(), 10);
|
|
}
|
|
|
|
|
|
static void AddDebugBreak(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::debug::DebugBreak(args.GetIsolate());
|
|
}
|
|
|
|
|
|
TEST(DebugBreakStackTrace) {
|
|
DebugLocalContext env;
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
SetDebugEventListener(env->GetIsolate(), DebugBreakStackTraceListener);
|
|
v8::Local<v8::Context> context = env.context();
|
|
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);
|
|
bool terminate_already_fired = false;
|
|
|
|
|
|
static void DebugBreakTriggerTerminate(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
if (event_details.GetEvent() != v8::Break || 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;
|
|
}
|
|
|
|
|
|
class TerminationThread : public v8::base::Thread {
|
|
public:
|
|
explicit TerminationThread(v8::Isolate* isolate)
|
|
: Thread(Options("terminator")), isolate_(isolate) {}
|
|
|
|
virtual void Run() {
|
|
terminate_requested_semaphore.Wait();
|
|
isolate_->TerminateExecution();
|
|
terminate_fired_semaphore.Signal();
|
|
}
|
|
|
|
private:
|
|
v8::Isolate* isolate_;
|
|
};
|
|
|
|
|
|
TEST(DebugBreakOffThreadTerminate) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
SetDebugEventListener(isolate, DebugBreakTriggerTerminate);
|
|
TerminationThread terminator(isolate);
|
|
terminator.Start();
|
|
v8::TryCatch try_catch(env->GetIsolate());
|
|
v8::debug::DebugBreak(isolate);
|
|
CompileRun("while (true);");
|
|
CHECK(try_catch.HasTerminated());
|
|
}
|
|
|
|
|
|
static void DebugEventExpectNoException(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
CHECK_NE(v8::Exception, event);
|
|
}
|
|
|
|
|
|
static void TryCatchWrappedThrowCallback(
|
|
const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::TryCatch try_catch(args.GetIsolate());
|
|
CompileRun("throw 'rejection';");
|
|
CHECK(try_catch.HasCaught());
|
|
}
|
|
|
|
|
|
TEST(DebugPromiseInterceptedByTryCatch) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
SetDebugEventListener(isolate, &DebugEventExpectNoException);
|
|
v8::Local<v8::Context> context = env.context();
|
|
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());
|
|
}
|
|
|
|
|
|
static int exception_event_counter = 0;
|
|
|
|
|
|
static void DebugEventCountException(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
if (event == v8::Exception) exception_event_counter++;
|
|
}
|
|
|
|
|
|
static void ThrowCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
CompileRun("throw 'rejection';");
|
|
}
|
|
|
|
|
|
TEST(DebugPromiseRejectedByCallback) {
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
SetDebugEventListener(isolate, &DebugEventCountException);
|
|
v8::Local<v8::Context> context = env.context();
|
|
ChangeBreakOnException(false, true);
|
|
exception_event_counter = 0;
|
|
|
|
v8::Local<v8::FunctionTemplate> fun =
|
|
v8::FunctionTemplate::New(isolate, ThrowCallback);
|
|
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(e) { r = 'rejected' + e; });");
|
|
CHECK(
|
|
CompileRun("r")->Equals(context, v8_str("rejectedrejection")).FromJust());
|
|
CHECK_EQ(1, exception_event_counter);
|
|
}
|
|
|
|
|
|
static void DebugHarmonyScopingListener(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
if (event != v8::Break) return;
|
|
|
|
int break_id = CcTest::i_isolate()->debug()->break_id();
|
|
|
|
char script[128];
|
|
i::Vector<char> script_vector(script, sizeof(script));
|
|
SNPrintF(script_vector, "%%GetFrameCount(%d)", break_id);
|
|
ExpectInt32(script, 1);
|
|
|
|
SNPrintF(script_vector, "var frame = new FrameMirror(%d, 0);", break_id);
|
|
CompileRun(script);
|
|
ExpectInt32("frame.evaluate('x').value_", 1);
|
|
ExpectInt32("frame.evaluate('y').value_", 2);
|
|
|
|
CompileRun("var allScopes = frame.allScopes()");
|
|
ExpectInt32("allScopes.length", 2);
|
|
|
|
ExpectBoolean("allScopes[0].scopeType() === ScopeType.Script", true);
|
|
|
|
ExpectInt32("allScopes[0].scopeObject().value_.x", 1);
|
|
|
|
ExpectInt32("allScopes[0].scopeObject().value_.y", 2);
|
|
|
|
CompileRun("allScopes[0].setVariableValue('x', 5);");
|
|
CompileRun("allScopes[0].setVariableValue('y', 6);");
|
|
ExpectInt32("frame.evaluate('x + y').value_", 11);
|
|
}
|
|
|
|
|
|
TEST(DebugBreakInLexicalScopes) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
SetDebugEventListener(isolate, DebugHarmonyScopingListener);
|
|
|
|
CompileRun(
|
|
"'use strict'; \n"
|
|
"let x = 1; \n");
|
|
ExpectInt32(
|
|
"'use strict'; \n"
|
|
"let y = 2; \n"
|
|
"debugger; \n"
|
|
"x * y",
|
|
30);
|
|
ExpectInt32(
|
|
"x = 1; y = 2; \n"
|
|
"debugger;"
|
|
"x * y",
|
|
30);
|
|
}
|
|
|
|
static int after_compile_handler_depth = 0;
|
|
static void HandleInterrupt(v8::Isolate* isolate, void* data) {
|
|
CHECK_EQ(0, after_compile_handler_depth);
|
|
}
|
|
|
|
static void NoInterruptsOnDebugEvent(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
if (event_details.GetEvent() != v8::AfterCompile) return;
|
|
++after_compile_handler_depth;
|
|
// Do not allow nested AfterCompile events.
|
|
CHECK_LE(after_compile_handler_depth, 1);
|
|
v8::Isolate* isolate = event_details.GetEventContext()->GetIsolate();
|
|
v8::Isolate::AllowJavascriptExecutionScope allow_script(isolate);
|
|
isolate->RequestInterrupt(&HandleInterrupt, nullptr);
|
|
CompileRun("function foo() {}; foo();");
|
|
--after_compile_handler_depth;
|
|
}
|
|
|
|
TEST(NoInterruptsInDebugListener) {
|
|
DebugLocalContext env;
|
|
SetDebugEventListener(env->GetIsolate(), NoInterruptsOnDebugEvent);
|
|
CompileRun("void(0);");
|
|
}
|
|
|
|
TEST(BreakLocationIterator) {
|
|
DebugLocalContext 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());
|
|
|
|
EnableDebugger(isolate);
|
|
CHECK(i_isolate->debug()->EnsureBreakInfo(shared));
|
|
|
|
Handle<i::DebugInfo> debug_info(shared->GetDebugInfo());
|
|
|
|
{
|
|
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);
|
|
}
|
|
|
|
size_t current_action = 0;
|
|
StepAction actions[] = {StepNext, StepNext};
|
|
static void DebugStepOverFunctionWithCaughtExceptionListener(
|
|
const v8::Debug::EventDetails& event_details) {
|
|
v8::DebugEvent event = event_details.GetEvent();
|
|
if (event != v8::Break) return;
|
|
++break_point_hit_count;
|
|
if (current_action >= 2) return;
|
|
PrepareStep(actions[current_action]);
|
|
}
|
|
|
|
TEST(DebugStepOverFunctionWithCaughtException) {
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
DebugLocalContext env;
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
v8::HandleScope scope(isolate);
|
|
SetDebugEventListener(isolate,
|
|
DebugStepOverFunctionWithCaughtExceptionListener);
|
|
|
|
break_point_hit_count = 0;
|
|
CompileRun(
|
|
"function foo() {\n"
|
|
" try { throw new Error(); } catch (e) {}\n"
|
|
"}\n"
|
|
"debugger;\n"
|
|
"foo();\n"
|
|
"foo();\n");
|
|
|
|
SetDebugEventListener(env->GetIsolate(), nullptr);
|
|
CHECK_EQ(4, break_point_hit_count);
|
|
}
|
|
|
|
bool out_of_memory_callback_called = false;
|
|
void OutOfMemoryCallback(void* data) {
|
|
out_of_memory_callback_called = true;
|
|
reinterpret_cast<v8::Isolate*>(data)->IncreaseHeapLimitForDebugging();
|
|
}
|
|
|
|
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);
|
|
v8::debug::SetOutOfMemoryCallback(isolate, OutOfMemoryCallback,
|
|
reinterpret_cast<void*>(isolate));
|
|
CHECK(!out_of_memory_callback_called);
|
|
// The following allocation fails unless the out-of-memory callback
|
|
// increases the heap limit.
|
|
int length = 10 * i::MB / i::kPointerSize;
|
|
i_isolate->factory()->NewFixedArray(length, i::TENURED);
|
|
CHECK(out_of_memory_callback_called);
|
|
}
|
|
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::Coverage::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::Coverage::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::Coverage::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::Snapshot::EnsureAllBuiltinsAreDeserialized(iisolate);
|
|
|
|
i::Builtins* builtins = iisolate->builtins();
|
|
bool fail = false;
|
|
for (int i = 0; i < i::Builtins::builtin_count; i++) {
|
|
Code* builtin = builtins->builtin(i);
|
|
if (builtin->kind() != 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());
|
|
while (i::HeapObject* obj = iterator.next()) {
|
|
if (!obj->IsJSFunction()) continue;
|
|
i::JSFunction* fun = i::JSFunction::cast(obj);
|
|
all_functions.emplace_back(fun);
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
{
|
|
i::NoSideEffectScope scope(isolate, true);
|
|
failed = !isolate->debug()->PerformSideEffectCheck(fun);
|
|
}
|
|
if (failed) isolate->clear_pending_exception();
|
|
}
|
|
DisableDebugger(env->GetIsolate());
|
|
}
|