From 6098abf46e804a8273b99cc0b4dacd0419a0601e Mon Sep 17 00:00:00 2001 From: "ager@chromium.org" Date: Mon, 18 Jul 2011 14:29:50 +0000 Subject: [PATCH] Fix the debugger for strict-mode functions. undefined is passed unchanged as the receiver for strict-mode functions through call and apply. Also, if a strict-mode function is called without an explicit receiver, undefined is passed as the receiver (not the global object as for other functions). R=vegorov@chromium.org BUG=89236 TEST=mjsunit/debug-scopes.js Review URL: http://codereview.chromium.org/7388011 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@8675 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/mirror-debugger.js | 6 +- src/runtime.cc | 12 ++-- test/mjsunit/debug-receiver.js | 126 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 137 insertions(+), 7 deletions(-) create mode 100644 test/mjsunit/debug-receiver.js diff --git a/src/mirror-debugger.js b/src/mirror-debugger.js index 0a32597..bad0800 100644 --- a/src/mirror-debugger.js +++ b/src/mirror-debugger.js @@ -1605,8 +1605,10 @@ FrameMirror.prototype.invocationText = function() { // Try to find the function as a property in the receiver. Include the // prototype chain in the lookup. var property = GetUndefinedMirror(); - if (!receiver.isUndefined()) { - for (var r = receiver; !r.isNull() && property.isUndefined(); r = r.protoObject()) { + if (receiver.isObject()) { + for (var r = receiver; + !r.isNull() && property.isUndefined(); + r = r.protoObject()) { property = r.lookupProperty(func); } } diff --git a/src/runtime.cc b/src/runtime.cc index 89b70cc..da20e8a 100644 --- a/src/runtime.cc +++ b/src/runtime.cc @@ -10136,7 +10136,8 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetFrameDetails) { // Get scope info and read from it for local variable information. Handle function(JSFunction::cast(it.frame()->function())); - Handle scope_info(function->shared()->scope_info()); + Handle shared(function->shared()); + Handle scope_info(shared->scope_info()); ASSERT(*scope_info != SerializedScopeInfo::Empty()); ScopeInfo<> info(*scope_info); @@ -10308,10 +10309,11 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetFrameDetails) { // THIS MUST BE DONE LAST SINCE WE MIGHT ADVANCE // THE FRAME ITERATOR TO WRAP THE RECEIVER. Handle receiver(it.frame()->receiver(), isolate); - if (!receiver->IsJSObject()) { - // If the receiver is NOT a JSObject we have hit an optimization - // where a value object is not converted into a wrapped JS objects. - // To hide this optimization from the debugger, we wrap the receiver + if (!receiver->IsJSObject() && !shared->strict_mode() && !shared->native()) { + // If the receiver is not a JSObject and the function is not a + // builtin or strict-mode we have hit an optimization where a + // value object is not converted into a wrapped JS objects. To + // hide this optimization from the debugger, we wrap the receiver // by creating correct wrapper object based on the calling frame's // global context. it.Advance(); diff --git a/test/mjsunit/debug-receiver.js b/test/mjsunit/debug-receiver.js new file mode 100644 index 0000000..21cdde8 --- /dev/null +++ b/test/mjsunit/debug-receiver.js @@ -0,0 +1,126 @@ +// Copyright 2011 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. + +// Flags: --expose-debug-as debug +// Get the Debug object exposed from the debug context global object. +Debug = debug.Debug; + +var test_name; +var listener_delegate; +var listener_called; +var exception; +var expected_receiver; +var begin_test_count = 0; +var end_test_count = 0; +var break_count = 0; + +// Debug event listener which delegates. Exceptions have to be +// explictly caught here and checked later because exception in the +// listener are not propagated to the surrounding JavaScript code. +function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Break) { + break_count++; + listener_called = true; + listener_delegate(exec_state); + } + } catch (e) { + exception = e; + } +} + +// Add the debug event listener. +Debug.setListener(listener); + + +// Initialize for a new test. +function BeginTest(name) { + test_name = name; + listener_called = false; + exception = null; + begin_test_count++; +} + + +// Check result of a test. +function EndTest() { + assertTrue(listener_called, "listerner not called for " + test_name); + assertNull(exception, test_name); + end_test_count++; +} + + +// Check that the debugger correctly reflects that the receiver is not +// converted to object for strict mode functions. +function Strict() { "use strict"; debugger; } +function TestStrict(receiver) { + expected_receiver = receiver; + Strict.call(receiver); +} + +listener_delegate = function(exec_state) { + var receiver = exec_state.frame().receiver(); + assertTrue(!receiver.isObject()); + assertEquals(expected_receiver, receiver.value()) +} + +BeginTest("strict: undefined"); TestStrict(undefined); EndTest(); +BeginTest("strict: null"); TestStrict(null); EndTest(); +BeginTest("strict: 1"); TestStrict(1); EndTest(); +BeginTest("strict: 1.2"); TestStrict(1.2); EndTest(); +BeginTest("strict: 'asdf'"); TestStrict('asdf'); EndTest(); +BeginTest("strict: true"); TestStrict(true); EndTest(); + + +// Check that the debugger correctly reflects the object conversion of +// the receiver for non-strict mode functions. +function NonStrict() { debugger; } +function TestNonStrict(receiver) { + // null and undefined should be transformed to the global object and + // primitives should be wrapped. + expected_receiver = (receiver == null) ? this : Object(receiver); + NonStrict.call(receiver); +} + +listener_delegate = function(exec_state) { + var receiver = exec_state.frame().receiver(); + assertTrue(receiver.isObject()); + assertEquals(expected_receiver, receiver.value()); +} + +BeginTest("non-strict: undefined"); TestNonStrict(undefined); EndTest(); +BeginTest("non-strict: null"); TestNonStrict(null); EndTest(); +BeginTest("non-strict: 1"); TestNonStrict(1); EndTest(); +BeginTest("non-strict: 1.2"); TestNonStrict(1.2); EndTest(); +BeginTest("non-strict: 'asdf'"); TestNonStrict('asdf'); EndTest(); +BeginTest("non-strict: true"); TestNonStrict(true); EndTest(); + + +assertEquals(begin_test_count, break_count, + 'one or more tests did not enter the debugger'); +assertEquals(begin_test_count, end_test_count, + 'one or more tests did not have its result checked'); -- 2.7.4