Debugger: require debugger to be active when dealing with breaks.

test/cctest/test-debug.cc

 // 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
@@ skipping 427 matching lines @@
   v8::internal::CheckDebuggerUnloaded(check_functions);
 }
 
 
 // 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) {
+  EnableDebugger();
   i::Debug* debug = CcTest::i_isolate()->debug();
 
   // Create function and set the break point.
   Handle<i::JSFunction> fun =
       v8::Utils::OpenHandle(*CompileFunction(env, source, name));
   int bp = SetBreakPoint(fun, position);
 
   // Check that the debug break function is as expected.
   Handle<i::SharedFunctionInfo> shared(fun->shared());
   CHECK(Debug::HasDebugInfo(shared));
@@ skipping 23 matching lines @@
                                             i::STATEMENT_ALIGNED);
   actual_mode = location.rmode();
   if (actual_mode == i::RelocInfo::CODE_TARGET_WITH_ID) {
     actual_mode = i::RelocInfo::CODE_TARGET;
   }
   CHECK_EQ(mode, actual_mode);
   if (mode == i::RelocInfo::JS_RETURN) {
     i::RelocInfo rinfo = location.rinfo();
     CHECK(!rinfo.IsPatchedReturnSequence());
   }
+
+  DisableDebugger();
 }
 
 
 // --- 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
@@ skipping 478 matching lines @@
                           "function f1(){}", "f1",
                           0,
                           v8::internal::RelocInfo::JS_RETURN,
                           NULL);
   CheckDebugBreakFunction(&env,
                           "function f2(){x=1;}", "f2",
                           0,
                           v8::internal::RelocInfo::CODE_TARGET,
                           CcTest::i_isolate()->builtins()->builtin(
                               Builtins::kStoreIC_DebugBreak));
-  CheckDebugBreakFunction(&env,
-                          "function f3(){var a=x;}", "f3",
-                          0,
-                          v8::internal::RelocInfo::CODE_TARGET,
-                          CcTest::i_isolate()->builtins()->builtin(
-                              Builtins::kLoadIC_DebugBreak));
+  CheckDebugBreakFunction(
+      &env, "function f3(){x();}", "f3", 0,
+      v8::internal::RelocInfo::CODE_TARGET,
+      CcTest::i_isolate()->builtins()->builtin(Builtins::kLoadIC_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,
+      "f4", 39, v8::internal::RelocInfo::CODE_TARGET,
       CcTest::i_isolate()->builtins()->builtin(
           Builtins::kKeyedStoreIC_DebugBreak));
   CheckDebugBreakFunction(
       &env,
       "function f5(){var index='propertyName'; var a={}; return a[index];}",
-      "f5",
-      0,
-      v8::internal::RelocInfo::CODE_TARGET,
+      "f5", 39, v8::internal::RelocInfo::CODE_TARGET,
       CcTest::i_isolate()->builtins()->builtin(
           Builtins::kKeyedLoadIC_DebugBreak));
 #endif
 
-  CheckDebugBreakFunction(
-      &env,
-      "function f6(a){return a==null;}",
-      "f6",
-      0,
-      v8::internal::RelocInfo::CODE_TARGET,
-      CcTest::i_isolate()->builtins()->builtin(
-          Builtins::kCompareNilIC_DebugBreak));
+  CheckDebugBreakFunction(&env, "function f6(){(0==null)()}", "f6", 0,
+                          v8::internal::RelocInfo::CODE_TARGET,
+                          CcTest::i_isolate()->builtins()->builtin(
+                              Builtins::kCompareNilIC_DebugBreak));
 
   // Check the debug break code stubs for call ICs with different number of
   // parameters.
   // TODO(verwaest): XXX update test.
   // 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",
@@ skipping 22 matching lines @@
   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(!HasDebugInfo(foo));
   CHECK(!HasDebugInfo(bar));
+  EnableDebugger();
   // 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);
+  DisableDebugger();
   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;
   DebugLocalContext env;
@@ skipping 1187 matching lines @@
 
 
 // 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::Function> foo =
       CompileFunction(&env, "function foo(){a=1;}", "foo");
-  debug_event_remove_break_point = SetBreakPoint(foo, 0);
 
   // Register the debug event listener pasing the function
   v8::Debug::SetDebugEventListener(DebugEventRemoveBreakPoint, foo);
 
+  debug_event_remove_break_point = SetBreakPoint(foo, 0);
+
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded();
@@ skipping 466 matching lines @@
   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();");
 
-  SetBreakPoint(foo, 3);
-
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(DebugEventStep);
 
+  SetBreakPoint(foo, 3);
+
   step_action = StepIn;
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // With stepping all break locations are hit.
   CHECK_EQ(4, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded();
 
@@ skipping 2773 matching lines @@
 TEST(RecursiveBreakpoints) {
   TestRecursiveBreakpointsGeneric(false);
 }
 
 
 TEST(RecursiveBreakpointsGlobal) {
   TestRecursiveBreakpointsGeneric(true);
 }
 
 
-static void DummyDebugEventListener(
-    const v8::Debug::EventDetails& event_details) {
-}
-
-
 TEST(SetDebugEventListenerOnUninitializedVM) {
   v8::Debug::SetDebugEventListener(DummyDebugEventListener);
 }
 
 
 static void DummyMessageHandler(const v8::Debug::Message& message) {
 }
 
 
 TEST(SetMessageHandlerOnUninitializedVM) {
@@ skipping 353 matching lines @@
 TEST(DebugGetLoadedScripts) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   EmptyExternalStringResource source_ext_str;
   v8::Local<v8::String> source =
       v8::String::NewExternal(env->GetIsolate(), &source_ext_str);
   v8::Handle<v8::Script> evil_script(v8::Script::Compile(source));
   // "use" evil_script to make the compiler happy.
-  (void) evil_script;
+  USE(evil_script);
   Handle<i::ExternalTwoByteString> i_source(
       i::ExternalTwoByteString::cast(*v8::Utils::OpenHandle(*source)));
   // This situation can happen if source was an external string disposed
   // by its owner.
   i_source->set_resource(0);
 
   bool allow_natives_syntax = i::FLAG_allow_natives_syntax;
   i::FLAG_allow_natives_syntax = true;
+  EnableDebugger();
   CompileRun(
       "var scripts = %DebugGetLoadedScripts();"
       "var count = scripts.length;"
       "for (var i = 0; i < count; ++i) {"
       "  scripts[i].line_ends;"
       "}");
+  DisableDebugger();
   // Must not crash while accessing line_ends.
   i::FLAG_allow_natives_syntax = allow_natives_syntax;
 
   // Some scripts are retrieved - at least the number of native scripts.
   CHECK_GT((*env)
                ->Global()
                ->Get(v8::String::NewFromUtf8(env->GetIsolate(), "count"))
                ->Int32Value(),
            8);
 }
@@ skipping 547 matching lines @@
 
 // Tests after compile event is sent when there are some provisional
 // breakpoints out of the scripts lines range.
 TEST(ProvisionalBreakpointOnLineOutOfRange) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
   const char* script = "function f() {};";
   const char* resource_name = "test_resource";
 
+  v8::Debug::SetMessageHandler(AfterCompileMessageHandler);
+
   // Set a couple of provisional breakpoint on lines out of the script lines
   // range.
   int sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), resource_name,
                                              3, -1 /* no column */);
   int sbp2 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), resource_name, 5, 5);
 
   after_compile_message_count = 0;
-  v8::Debug::SetMessageHandler(AfterCompileMessageHandler);
 
   v8::ScriptOrigin origin(
       v8::String::NewFromUtf8(env->GetIsolate(), resource_name),
       v8::Integer::New(env->GetIsolate(), 10),
       v8::Integer::New(env->GetIsolate(), 1));
   // Compile a script whose first line number is greater than the breakpoints'
   // lines.
   v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), script),
                       &origin)->Run();
 
@@ skipping 1086 matching lines @@
       "let y = 2;               \n"
       "debugger;                \n"
       "x * y",
       30);
   ExpectInt32(
       "x = 1; y = 2; \n"
       "debugger;"
       "x * y",
       30);
 }