CSE2410 Fall 2014 Bounce

// Copyright 2007-2008 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 "v8.h"

#include "api.h"

#include "debug.h"

#include "platform.h"

#include "stub-cache.h"

#include "cctest.h"

using ::v8::internal::EmbeddedVector;

using ::v8::internal::Object;

using ::v8::internal::OS;

using ::v8::internal::Handle;

using ::v8::internal::Heap;

using ::v8::internal::JSGlobalProxy;

using ::v8::internal::Code;

using ::v8::internal::Debug;

using ::v8::internal::Debugger;

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

// Size of temp buffer for formatting small strings.

#define SMALL_STRING_BUFFER_SIZE 80

// --- A d d i t i o n a l   C h e c k   H e l p e r s

// Helper function used by the CHECK_EQ function when given Address

// arguments.  Should not be called directly.

static inline void CheckEqualsHelper(const char* file, int line,

                                     const char* expected_source,

                                     ::v8::internal::Address expected,

                                     const char* value_source,

                                     ::v8::internal::Address value) {

  if (expected != value) {

    V8_Fatal(file, line, "CHECK_EQ(%s, %s) failed\n#   "

                         "Expected: %i\n#   Found: %i",

             expected_source, value_source, expected, value);

  }

}

// Helper function used by the CHECK_NE function when given Address

// arguments.  Should not be called directly.

static inline void CheckNonEqualsHelper(const char* file, int line,

                                        const char* unexpected_source,

                                        ::v8::internal::Address unexpected,

                                        const char* value_source,

                                        ::v8::internal::Address value) {

  if (unexpected == value) {

    V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n#   Value: %i",

             unexpected_source, value_source, value);

  }

}

// Helper function used by the CHECK function when given code

// arguments.  Should not be called directly.

static inline void CheckEqualsHelper(const char* file, int line,

                                     const char* expected_source,

                                     const Code* expected,

                                     const char* value_source,

                                     const Code* value) {

  if (expected != value) {

    V8_Fatal(file, line, "CHECK_EQ(%s, %s) failed\n#   "

                         "Expected: %p\n#   Found: %p",

             expected_source, value_source, expected, value);

  }

}

static inline void CheckNonEqualsHelper(const char* file, int line,

                                        const char* expected_source,

                                        const Code* expected,

                                        const char* value_source,

                                        const Code* value) {

  if (expected == value) {

    V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n#   Value: %p",

             expected_source, value_source, value);

  }

}

// --- 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::ExtensionConfiguration* extensions = 0,

      v8::Handle<v8::ObjectTemplate> global_template =

          v8::Handle<v8::ObjectTemplate>(),

      v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>())

      : context_(v8::Context::New(extensions, global_template, global_object)) {

    context_->Enter();

  }

  inline ~DebugLocalContext() {

    context_->Exit();

    context_.Dispose();

  }

  inline v8::Context* operator->() { return *context_; }

  inline v8::Context* operator*() { return *context_; }

  inline bool IsReady() { return !context_.IsEmpty(); }

  void ExposeDebug() {

    // Expose the debug context global object in the global object for testing.

    Debug::Load();

    Debug::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 =

        v8::internal::Factory::LookupAsciiSymbol("debug");

    SetProperty(global, debug_string,

        Handle<Object>(Debug::debug_context()->global_proxy()), DONT_ENUM);

  }

 private:

  v8::Persistent<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 fequested function.

static v8::Local<v8::Function> CompileFunction(DebugLocalContext* env,

                                               const char* source,

                                               const char* function_name) {

  v8::Script::Compile(v8::String::New(source))->Run();

  return v8::Local<v8::Function>::Cast(

      (*env)->Global()->Get(v8::String::New(function_name)));

}

// Helper function that compiles and runs the source.

static v8::Local<v8::Value> CompileRun(const char* source) {

  return v8::Script::Compile(v8::String::New(source))->Run();

}

// Is there any debug info for the function?

static bool HasDebugInfo(v8::Handle<v8::Function> fun) {

  Handle<v8::internal::JSFunction> f = v8::Utils::OpenHandle(*fun);

  Handle<v8::internal::SharedFunctionInfo> shared(f->shared());

  return Debug::HasDebugInfo(shared);

}

// Set a break point in a function and return the associated break point

// number.

static int SetBreakPoint(Handle<v8::internal::JSFunction> fun, int position) {

  static int break_point = 0;

  Handle<v8::internal::SharedFunctionInfo> shared(fun->shared());

  Debug::SetBreakPoint(

      shared, position,

      Handle<Object>(v8::internal::Smi::FromInt(++break_point)));

  return break_point;

}

// Set a break point in a function and return the associated break point

// number.

static int SetBreakPoint(v8::Handle<v8::Function> fun, int position) {

  return SetBreakPoint(v8::Utils::OpenHandle(*fun), position);

}

// Set a break point in a function using the Debug object and return the

// associated break point number.

static int SetBreakPointFromJS(const char* function_name,

                               int line, int position) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  OS::SNPrintF(buffer,

               "debug.Debug.setBreakPoint(%s,%d,%d)",

               function_name, line, position);

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  v8::Handle<v8::String> str = v8::String::New(buffer.start());

  return v8::Script::Compile(str)->Run()->Int32Value();

}

// Set a break point in a script identified by id using the global Debug object.

static int SetScriptBreakPointByIdFromJS(int script_id, int line, int column) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  if (column >= 0) {

    // Column specified set script break point on precise location.

    OS::SNPrintF(buffer,

                 "debug.Debug.setScriptBreakPointById(%d,%d,%d)",

                 script_id, line, column);

  } else {

    // Column not specified set script break point on line.

    OS::SNPrintF(buffer,

                 "debug.Debug.setScriptBreakPointById(%d,%d)",

                 script_id, line);

  }

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  {

    v8::TryCatch try_catch;

    v8::Handle<v8::String> str = v8::String::New(buffer.start());

    v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();

    ASSERT(!try_catch.HasCaught());

    return value->Int32Value();

  }

}

// Set a break point in a script identified by name using the global Debug

// object.

static int SetScriptBreakPointByNameFromJS(const char* script_name,

                                           int line, int column) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  if (column >= 0) {

    // Column specified set script break point on precise location.

    OS::SNPrintF(buffer,

                 "debug.Debug.setScriptBreakPointByName(\"%s\",%d,%d)",

                 script_name, line, column);

  } else {

    // Column not specified set script break point on line.

    OS::SNPrintF(buffer,

                 "debug.Debug.setScriptBreakPointByName(\"%s\",%d)",

                 script_name, line);

  }

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  {

    v8::TryCatch try_catch;

    v8::Handle<v8::String> str = v8::String::New(buffer.start());

    v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();

    ASSERT(!try_catch.HasCaught());

    return value->Int32Value();

  }

}

// Clear a break point.

static void ClearBreakPoint(int break_point) {

  Debug::ClearBreakPoint(

      Handle<Object>(v8::internal::Smi::FromInt(break_point)));

}

// Clear a break point using the global Debug object.

static void ClearBreakPointFromJS(int break_point_number) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  OS::SNPrintF(buffer,

               "debug.Debug.clearBreakPoint(%d)",

               break_point_number);

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  v8::Script::Compile(v8::String::New(buffer.start()))->Run();

}

static void EnableScriptBreakPointFromJS(int break_point_number) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  OS::SNPrintF(buffer,

               "debug.Debug.enableScriptBreakPoint(%d)",

               break_point_number);

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  v8::Script::Compile(v8::String::New(buffer.start()))->Run();

}

static void DisableScriptBreakPointFromJS(int break_point_number) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  OS::SNPrintF(buffer,

               "debug.Debug.disableScriptBreakPoint(%d)",

               break_point_number);

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  v8::Script::Compile(v8::String::New(buffer.start()))->Run();

}

static void ChangeScriptBreakPointConditionFromJS(int break_point_number,

                                                  const char* condition) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  OS::SNPrintF(buffer,

               "debug.Debug.changeScriptBreakPointCondition(%d, \"%s\")",

               break_point_number, condition);

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  v8::Script::Compile(v8::String::New(buffer.start()))->Run();

}

static void ChangeScriptBreakPointIgnoreCountFromJS(int break_point_number,

                                                    int ignoreCount) {

  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;

  OS::SNPrintF(buffer,

               "debug.Debug.changeScriptBreakPointIgnoreCount(%d, %d)",

               break_point_number, ignoreCount);

  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';

  v8::Script::Compile(v8::String::New(buffer.start()))->Run();

}

// Change break on exception.

static void ChangeBreakOnException(bool caught, bool uncaught) {

  Debug::ChangeBreakOnException(v8::internal::BreakException, caught);

  Debug::ChangeBreakOnException(v8::internal::BreakUncaughtException, uncaught);

}

// Change break on exception using the global Debug object.

static void ChangeBreakOnExceptionFromJS(bool caught, bool uncaught) {

  if (caught) {

    v8::Script::Compile(

        v8::String::New("debug.Debug.setBreakOnException()"))->Run();

  } else {

    v8::Script::Compile(

        v8::String::New("debug.Debug.clearBreakOnException()"))->Run();

  }

  if (uncaught) {

    v8::Script::Compile(

        v8::String::New("debug.Debug.setBreakOnUncaughtException()"))->Run();

  } else {

    v8::Script::Compile(

        v8::String::New("debug.Debug.clearBreakOnUncaughtException()"))->Run();

  }

}

// Prepare to step to next break location.

static void PrepareStep(StepAction step_action) {

  Debug::PrepareStep(step_action, 1);

}

// This function is in namespace v8::internal to be friend with class

// v8::internal::Debug.

namespace v8 { namespace internal {  // NOLINT

// Collect the currently debugged functions.

Handle<FixedArray> GetDebuggedFunctions() {

  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 =

      v8::internal::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;

}

static Handle<Code> ComputeCallDebugBreak(int argc) {

  CALL_HEAP_FUNCTION(v8::internal::StubCache::ComputeCallDebugBreak(argc),

                     Code);

}

// Check that the debugger has been fully unloaded.

void CheckDebuggerUnloaded(bool check_functions) {

  // Check that the debugger context is cleared and that there is no debug

  // information stored for the debugger.

  CHECK(Debug::debug_context().is_null());

  CHECK_EQ(NULL, Debug::debug_info_list_);

  // Collect garbage to ensure weak handles are cleared.

  Heap::CollectAllGarbage();

  Heap::CollectAllGarbage();

  // Iterate the head and check that there are no debugger related objects left.

  HeapIterator iterator;

  while (iterator.has_next()) {

    HeapObject* obj = iterator.next();

    CHECK(obj != NULL);

    CHECK(!obj->IsDebugInfo());

    CHECK(!obj->IsBreakPointInfo());

    // If deep check of functions is requested check that no debug break code

    // is left in all functions.

    if (check_functions) {

      if (obj->IsJSFunction()) {

        JSFunction* fun = JSFunction::cast(obj);

        for (RelocIterator it(fun->shared()->code()); !it.done(); it.next()) {

          RelocInfo::Mode rmode = it.rinfo()->rmode();

          if (RelocInfo::IsCodeTarget(rmode)) {

            CHECK(!Debug::IsDebugBreak(it.rinfo()->target_address()));

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

            CHECK(!Debug::IsDebugBreakAtReturn(it.rinfo()));

          }

        }

      }

    }

  }

}

} }  // namespace v8::internal

// Check that the debugger has been fully unloaded.

static void CheckDebuggerUnloaded(bool check_functions = false) {

  v8::internal::CheckDebuggerUnloaded(check_functions);

}

// Inherit from BreakLocationIterator to get access to protected parts for

// testing.

class TestBreakLocationIterator: public v8::internal::BreakLocationIterator {

 public:

  explicit TestBreakLocationIterator(Handle<v8::internal::DebugInfo> debug_info)

    : BreakLocationIterator(debug_info, v8::internal::SOURCE_BREAK_LOCATIONS) {}

  v8::internal::RelocIterator* it() { return reloc_iterator_; }

  v8::internal::RelocIterator* it_original() {

    return reloc_iterator_original_;

  }

};

// Compile a function, set a break point and check that the call at the break

// location in the code is the expected debug_break function.

void CheckDebugBreakFunction(DebugLocalContext* env,

                             const char* source, const char* name,

                             int position, v8::internal::RelocInfo::Mode mode,

                             Code* debug_break) {

  // Create function and set the break point.

  Handle<v8::internal::JSFunction> fun = v8::Utils::OpenHandle(

      *CompileFunction(env, source, name));

  int bp = SetBreakPoint(fun, position);

  // Check that the debug break function is as expected.

  Handle<v8::internal::SharedFunctionInfo> shared(fun->shared());

  CHECK(Debug::HasDebugInfo(shared));

  TestBreakLocationIterator it1(Debug::GetDebugInfo(shared));

  it1.FindBreakLocationFromPosition(position);

  CHECK_EQ(mode, it1.it()->rinfo()->rmode());

  if (mode != v8::internal::RelocInfo::JS_RETURN) {

    CHECK_EQ(debug_break,

        Code::GetCodeFromTargetAddress(it1.it()->rinfo()->target_address()));

  } else {

    // TODO(1240753): Make the test architecture independent or split

    // parts of the debugger into architecture dependent files.

    CHECK_EQ(0xE8, *(it1.rinfo()->pc()));

  }

  // Clear the break point and check that the debug break function is no longer

  // there

  ClearBreakPoint(bp);

  CHECK(!Debug::HasDebugInfo(shared));

  CHECK(Debug::EnsureDebugInfo(shared));

  TestBreakLocationIterator it2(Debug::GetDebugInfo(shared));

  it2.FindBreakLocationFromPosition(position);

  CHECK_EQ(mode, it2.it()->rinfo()->rmode());

  if (mode == v8::internal::RelocInfo::JS_RETURN) {

    // TODO(1240753): Make the test architecture independent or split

    // parts of the debugger into architecture dependent files.

    CHECK_NE(0xE8, *(it2.rinfo()->pc()));

  }

}

// --- 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 the

// top frame.

const char* frame_function_name_source =

    "function frame_function_name(exec_state) {"

    "  return exec_state.frame(0).func().name();"

    "}";

v8::Local<v8::Function> frame_function_name;

// 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 returns the number of frames.

static const char* frame_count_source =

    "function frame_count(exec_state) {"

    "  return exec_state.frameCount();"

    "}";

v8::Handle<v8::Function> frame_count;

// Global variable to store the last function hit - used by some tests.

char last_function_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;

static void DebugEventBreakPointHitCount(v8::DebugEvent event,

                                         v8::Handle<v8::Object> exec_state,

                                         v8::Handle<v8::Object> event_data,

                                         v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::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 = 1;

      v8::Handle<v8::Value> argv[argc] = { exec_state };

      v8::Handle<v8::Value> result = frame_function_name->Call(exec_state,

                                                               argc, argv);

      if (result->IsUndefined()) {

        last_function_hit[0] = '\0';

      } else {

        CHECK(result->IsString());

        v8::Handle<v8::String> function_name(result->ToString());

        function_name->WriteAscii(last_function_hit);

      }

    }

    if (!frame_source_line.IsEmpty()) {

      // Get the source line.

      const int argc = 1;

      v8::Handle<v8::Value> argv[argc] = { exec_state };

      v8::Handle<v8::Value> result = frame_source_line->Call(exec_state,

                                                             argc, argv);

      CHECK(result->IsNumber());

      last_source_line = result->Int32Value();

    }

    if (!frame_source_column.IsEmpty()) {

      // Get the source column.

      const int argc = 1;

      v8::Handle<v8::Value> argv[argc] = { exec_state };

      v8::Handle<v8::Value> result = frame_source_column->Call(exec_state,

                                                               argc, argv);

      CHECK(result->IsNumber());

      last_source_column = result->Int32Value();

    }

  }

}

// 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(v8::DebugEvent event,

                              v8::Handle<v8::Object> exec_state,

                              v8::Handle<v8::Object> event_data,

                              v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::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::String::New("uncaught");

    v8::Local<v8::Function> fun =

        v8::Function::Cast(*event_data->Get(fun_name));

    v8::Local<v8::Value> result = *fun->Call(event_data, 0, NULL);

    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::Handle<v8::Value> argv[kArgc] = { exec_state };

    // Using exec_state as receiver is just to have a receiver.

    v8::Handle<v8::Value> result =  frame_count->Call(exec_state, kArgc, argv);

    last_js_stack_height = result->Int32Value();

  }

}

// 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::Handle<v8::Value> expected;  // The expected result.

};

// Array of checks to do.

struct EvaluateCheck* checks = NULL;

// 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(v8::DebugEvent event,

                               v8::Handle<v8::Object> exec_state,

                               v8::Handle<v8::Object> event_data,

                               v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::Debug::break_id(), 0);

  if (event == v8::Break) {

    for (int i = 0; checks[i].expr != NULL; i++) {

      const int argc = 3;

      v8::Handle<v8::Value> argv[argc] = { exec_state,

                                           v8::String::New(checks[i].expr),

                                           checks[i].expected };

      v8::Handle<v8::Value> result =

          evaluate_check_function->Call(exec_state, argc, argv);

      if (!result->IsTrue()) {

        v8::String::AsciiValue ascii(checks[i].expected->ToString());

        V8_Fatal(__FILE__, __LINE__, "%s != %s", checks[i].expr, *ascii);

      }

    }

  }

}

// This debug event listener removes a breakpoint in a function

int debug_event_remove_break_point = 0;

static void DebugEventRemoveBreakPoint(v8::DebugEvent event,

                                       v8::Handle<v8::Object> exec_state,

                                       v8::Handle<v8::Object> event_data,

                                       v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::Debug::break_id(), 0);

  if (event == v8::Break) {

    break_point_hit_count++;

    v8::Handle<v8::Function> fun = v8::Handle<v8::Function>::Cast(data);

    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(v8::DebugEvent event,

                           v8::Handle<v8::Object> exec_state,

                           v8::Handle<v8::Object> event_data,

                           v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::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 = NULL;

// The actual debug event described by the longer comment above.

static void DebugEventStepSequence(v8::DebugEvent event,

                                   v8::Handle<v8::Object> exec_state,

                                   v8::Handle<v8::Object> event_data,

                                   v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::Debug::break_id(), 0);

  if (event == v8::Break || event == v8::Exception) {

    // Check that the current function is the expected.

    CHECK(break_point_hit_count <

          static_cast<int>(strlen(expected_step_sequence)));

    const int argc = 1;

    v8::Handle<v8::Value> argv[argc] = { exec_state };

    v8::Handle<v8::Value> result = frame_function_name->Call(exec_state,

                                                             argc, argv);

    CHECK(result->IsString());

    v8::String::AsciiValue function_name(result->ToString());

    CHECK_EQ(1, strlen(*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(

    v8::DebugEvent event,

    v8::Handle<v8::Object> exec_state,

    v8::Handle<v8::Object> event_data,

    v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::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.

      Heap::CollectGarbage(0, v8::internal::NEW_SPACE);

    } else {

      // Mark sweep (and perhaps compact).

      Heap::CollectAllGarbage();

    }

  }

}

// Debug event handler which re-issues a debug break and calls the garbage

// collector to have the heap verified.

static void DebugEventBreak(v8::DebugEvent event,

                            v8::Handle<v8::Object> exec_state,

                            v8::Handle<v8::Object> event_data,

                            v8::Handle<v8::Value> data) {

  // When hitting a debug event listener there must be a break set.

  CHECK_NE(v8::internal::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.

    Heap::CollectGarbage(0, v8::internal::NEW_SPACE);

    // Set the break flag again to come back here as soon as possible.

    v8::Debug::DebugBreak();

  }

}

// --- 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::Handle<v8::Message> message,

                                 v8::Handle<v8::Value> data) {

  message_callback_count++;

}

// --- T h e   A c t u a l   T e s t s

// Test that the debug break function is the expected one for different kinds

// of break locations.

TEST(DebugStub) {

  using ::v8::internal::Builtins;

  v8::HandleScope scope;

  DebugLocalContext env;

  CheckDebugBreakFunction(&env,

                          "function f1(){}", "f1",

                          0,

                          v8::internal::RelocInfo::JS_RETURN,

                          NULL);

  CheckDebugBreakFunction(&env,

                          "function f2(){x=1;}", "f2",

                          0,

                          v8::internal::RelocInfo::CODE_TARGET,

                          Builtins::builtin(Builtins::StoreIC_DebugBreak));

  CheckDebugBreakFunction(&env,

                          "function f3(){var a=x;}", "f3",

                          0,

                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,

                          Builtins::builtin(Builtins::LoadIC_DebugBreak));

// TODO(1240753): Make the test architecture independent or split

// parts of the debugger into architecture dependent files. This

// part currently disabled as it is not portable between IA32/ARM.

// Currently on ICs for keyed store/load on ARM.

#if !defined (__arm__) && !defined(__thumb__)

  CheckDebugBreakFunction(

      &env,

      "function f4(){var index='propertyName'; var a={}; a[index] = 'x';}",

      "f4",

      0,

      v8::internal::RelocInfo::CODE_TARGET,

      Builtins::builtin(Builtins::KeyedStoreIC_DebugBreak));

  CheckDebugBreakFunction(

      &env,

      "function f5(){var index='propertyName'; var a={}; return a[index];}",

      "f5",

      0,

      v8::internal::RelocInfo::CODE_TARGET,

      Builtins::builtin(Builtins::KeyedLoadIC_DebugBreak));

#endif

  // Check the debug break code stubs for call ICs with different number of

  // parameters.

  Handle<Code> debug_break_0 = v8::internal::ComputeCallDebugBreak(0);

  Handle<Code> debug_break_1 = v8::internal::ComputeCallDebugBreak(1);

  Handle<Code> debug_break_4 = v8::internal::ComputeCallDebugBreak(4);

  CheckDebugBreakFunction(&env,

                          "function f4_0(){x();}", "f4_0",

                          0,

                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,

                          *debug_break_0);

  CheckDebugBreakFunction(&env,

                          "function f4_1(){x(1);}", "f4_1",

                          0,

                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,

                          *debug_break_1);

  CheckDebugBreakFunction(&env,

                          "function f4_4(){x(1,2,3,4);}", "f4_4",

                          0,

                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,

                          *debug_break_4);

}

// Test that the debug info in the VM is in sync with the functions being

// debugged.

TEST(DebugInfo) {

  v8::HandleScope scope;

  DebugLocalContext env;

  // 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(!HasDebugInfo(foo));

  CHECK(!HasDebugInfo(bar));

  // One function (foo) is debugged.

  int bp1 = SetBreakPoint(foo, 0);

  CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());

  CHECK(HasDebugInfo(foo));

  CHECK(!HasDebugInfo(bar));

  // Two functions are debugged.

  int bp2 = SetBreakPoint(bar, 0);

  CHECK_EQ(2, v8::internal::GetDebuggedFunctions()->length());

  CHECK(HasDebugInfo(foo));

  CHECK(HasDebugInfo(bar));

  // One function (bar) is debugged.

  ClearBreakPoint(bp1);

  CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());

  CHECK(!HasDebugInfo(foo));

  CHECK(HasDebugInfo(bar));

  // No functions are debugged.

  ClearBreakPoint(bp2);

  CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());

  CHECK(!HasDebugInfo(foo));

  CHECK(!HasDebugInfo(bar));

}

// Test that a break point can be set at an IC store location.

TEST(BreakPointICStore) {

  break_point_hit_count = 0;

  v8::HandleScope scope;

  DebugLocalContext env;

  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,

                                   v8::Undefined());

  v8::Script::Compile(v8::String::New("function foo(){bar=0;}"))->Run();

  v8::Local<v8::Function> foo =

      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));

  // Run without breakpoints.

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  // Run with breakpoint

  int bp = SetBreakPoint(foo, 0);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(1, break_point_hit_count);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  // Run without breakpoints.

  ClearBreakPoint(bp);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  v8::Debug::SetDebugEventListener(NULL);

  CheckDebuggerUnloaded();

}

// Test that a break point can be set at an IC load location.

TEST(BreakPointICLoad) {

  break_point_hit_count = 0;

  v8::HandleScope scope;

  DebugLocalContext env;

  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,

                                   v8::Undefined());

  v8::Script::Compile(v8::String::New("bar=1"))->Run();

  v8::Script::Compile(v8::String::New("function foo(){var x=bar;}"))->Run();

  v8::Local<v8::Function> foo =

      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));

  // Run without breakpoints.

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  // Run with breakpoint

  int bp = SetBreakPoint(foo, 0);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(1, break_point_hit_count);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  // Run without breakpoints.

  ClearBreakPoint(bp);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  v8::Debug::SetDebugEventListener(NULL);

  CheckDebuggerUnloaded();

}

// Test that a break point can be set at an IC call location.

TEST(BreakPointICCall) {

  break_point_hit_count = 0;

  v8::HandleScope scope;

  DebugLocalContext env;

  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,

                                   v8::Undefined());

  v8::Script::Compile(v8::String::New("function bar(){}"))->Run();

  v8::Script::Compile(v8::String::New("function foo(){bar();}"))->Run();

  v8::Local<v8::Function> foo =

      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));

  // Run without breakpoints.

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  // Run with breakpoint

  int bp = SetBreakPoint(foo, 0);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(1, break_point_hit_count);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  // Run without breakpoints.

  ClearBreakPoint(bp);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  v8::Debug::SetDebugEventListener(NULL);

  CheckDebuggerUnloaded();

}

// Test that a break point can be set at a return store location.

TEST(BreakPointReturn) {

  break_point_hit_count = 0;

  v8::HandleScope scope;

  DebugLocalContext env;

  // 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");

  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,

                                   v8::Undefined());

  v8::Script::Compile(v8::String::New("function foo(){}"))->Run();

  v8::Local<v8::Function> foo =

      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));

  // Run without breakpoints.

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  // Run with breakpoint

  int bp = SetBreakPoint(foo, 0);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(1, break_point_hit_count);

  CHECK_EQ(0, last_source_line);

  CHECK_EQ(16, last_source_column);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  CHECK_EQ(0, last_source_line);

  CHECK_EQ(16, last_source_column);

  // Run without breakpoints.

  ClearBreakPoint(bp);

  foo->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  v8::Debug::SetDebugEventListener(NULL);

  CheckDebuggerUnloaded();

}

static void CallWithBreakPoints(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(recv, 0, NULL);

    CHECK_EQ((i + 1) * break_point_count, break_point_hit_count);

  }

}

// Test GC during break point processing.

TEST(GCDuringBreakPointProcessing) {

  break_point_hit_count = 0;

  v8::HandleScope scope;

  DebugLocalContext env;

  v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage,

                                   v8::Undefined());

  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(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(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(env->Global(), foo, 1, 10);

  // Test return break point with garbage collection.

  foo = CompileFunction(&env, "function foo(){}", "foo");

  SetBreakPoint(foo, 0);

  CallWithBreakPoints(env->Global(), foo, 1, 25);

  v8::Debug::SetDebugEventListener(NULL);

  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::Object> recv, v8::Local<v8::Function> f) {

  break_point_hit_count = 0;

  for (int i = 0; i < 3; i++) {

    // Call function.

    f->Call(recv, 0, NULL);

    CHECK_EQ(1 + i * 3, break_point_hit_count);

    // Scavenge and call function.

    Heap::CollectGarbage(0, v8::internal::NEW_SPACE);

    f->Call(recv, 0, NULL);

    CHECK_EQ(2 + i * 3, break_point_hit_count);

    // Mark sweep (and perhaps compact) and call function.

    Heap::CollectAllGarbage();

    f->Call(recv, 0, NULL);

    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;

  v8::HandleScope scope;

  DebugLocalContext env;

  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,

                                   v8::Undefined());

  v8::Local<v8::Function> foo;

  // Test IC store break point with garbage collection.

  foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");

  SetBreakPoint(foo, 0);

  CallAndGC(env->Global(), foo);

  // Test IC load break point with garbage collection.

  foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");

  SetBreakPoint(foo, 0);

  CallAndGC(env->Global(), foo);

  // Test IC call break point with garbage collection.

  foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");

  SetBreakPoint(foo, 0);

  CallAndGC(env->Global(), foo);

  // Test return break point with garbage collection.

  foo = CompileFunction(&env, "function foo(){}", "foo");

  SetBreakPoint(foo, 0);

  CallAndGC(env->Global(), foo);

  v8::Debug::SetDebugEventListener(NULL);

  CheckDebuggerUnloaded();

}

// Test that break points can be set using the global Debug object.

TEST(BreakPointThroughJavaScript) {

  break_point_hit_count = 0;

  v8::HandleScope scope;

  DebugLocalContext env;

  env.ExposeDebug();

  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,

                                   v8::Undefined());

  v8::Script::Compile(v8::String::New("function bar(){}"))->Run();

  v8::Script::Compile(v8::String::New("function foo(){bar();bar();}"))->Run();

  //                                               012345678901234567890

  //                                                         1         2

  // Break points are set at position 3 and 9

  v8::Local<v8::Script> foo = v8::Script::Compile(v8::String::New("foo()"));

  // Run without breakpoints.

  foo->Run();

  CHECK_EQ(0, break_point_hit_count);

  // Run with one breakpoint

  int bp1 = SetBreakPointFromJS("foo", 0, 3);

  foo->Run();

  CHECK_EQ(1, break_point_hit_count);

  foo->Run();

  CHECK_EQ(2, break_point_hit_count);

  // Run with two breakpoints

  int bp2 = SetBreakPointFromJS("foo", 0, 9);

  foo->Run();

  CHECK_EQ(4, break_point_hit_count);

  foo->Run();

  CHECK_EQ(6, break_point_hit_count);

  // Run with one breakpoint

  ClearBreakPointFromJS(bp2);

  foo->Run();

  CHECK_EQ(7, break_point_hit_count);

  foo->Run();

  CHECK_EQ(8, break_point_hit_count);

  // Run without breakpoints.

  ClearBreakPointFromJS(bp1);

  foo->Run();

  CHECK_EQ(8, break_point_hit_count);

  v8::Debug::SetDebugEventListener(NULL);

  CheckDebuggerUnloaded();

  // Make sure that the break point numbers are consecutive.

  CHECK_EQ(1, bp1);

  CHECK_EQ(2, bp2);

}

// Test that break points on scripts identified by name can be set using the

// global Debug object.

TEST(ScriptBreakPointByNameThroughJavaScript) {

  break_point_hit_count = 0;

  v8::HandleScope scope;

  DebugLocalContext env;

  env.ExposeDebug();

  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,

                                   v8::Undefined());

  v8::Local<v8::String> script = v8::String::New(

    "function f() {\n"

    "  function h() {\n"

    "    a = 0;  // line 2\n"

    "  }\n"

    "  b = 1;  // line 4\n"

    "  return h();\n"

    "}\n"

    "\n"

    "function g() {\n"

    "  function h() {\n"

    "    a = 0;\n"

    "  }\n"

    "  b = 2;  // line 12\n"

    "  h();\n"

    "  b = 3;  // line 14\n"

    "  f();    // line 15\n"

    "}");

  // Compile the script and get the two functions.

  v8::ScriptOrigin origin =

      v8::ScriptOrigin(v8::String::New("test"));

  v8::Script::Compile(script, &origin)->Run();

  v8::Local<v8::Function> f =

      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));

  v8::Local<v8::Function> g =

      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));

  // Call f and g without break points.

  break_point_hit_count = 0;

  f->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  g->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  // Call f and g with break point on line 12.

  int sbp1 = SetScriptBreakPointByNameFromJS("test", 12, 0);

  break_point_hit_count = 0;

  f->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  g->Call(env->Global(), 0, NULL);

  CHECK_EQ(1, break_point_hit_count);

  // Remove the break point again.

  break_point_hit_count = 0;

  ClearBreakPointFromJS(sbp1);

  f->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  g->Call(env->Global(), 0, NULL);

  CHECK_EQ(0, break_point_hit_count);

  // Call f and g with break point on line 2.

  int sbp2 = SetScriptBreakPointByNameFromJS("test", 2, 0);

  break_point_hit_count = 0;

  f->Call(env->Global(), 0, NULL);

  CHECK_EQ(1, break_point_hit_count);

  g->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  // Call f and g with break point on line 2, 4, 12, 14 and 15.

  int sbp3 = SetScriptBreakPointByNameFromJS("test", 4, 0);

  int sbp4 = SetScriptBreakPointByNameFromJS("test", 12, 0);

  int sbp5 = SetScriptBreakPointByNameFromJS("test", 14, 0);

  int sbp6 = SetScriptBreakPointByNameFromJS("test", 15, 0);

  break_point_hit_count = 0;

  f->Call(env->Global(), 0, NULL);

  CHECK_EQ(2, break_point_hit_count);

  g->Call(env->Global(), 0, NULL);