AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
9e27d4735f
v8/test/inspector/debugger/step-into-expected.txt
Alexey Kozyatinskiy a8176a530c [ignition] removed nop bytecode 
Nop bytecodes are required only for break locations in debugger. Since nop bytecode doesn't change program state we can remove all of them.

There are at least two changes which this CL produce:
- we don't provide break position when we load local variable (still provide when load variable from global),
- we don't provide break position for statements without actual break positions (e.g. "a;") - these expressions should be super rare and user always can set breakpoint before or after this statement.

More details in one pager: https://docs.google.com/a/google.com/document/d/1JXlQpfMa9vRojbE272b6GMBbrfh6m_00135iAUOJEz8/edit?usp=sharing

Bug: v8:6425
Change-Id: I4aee73d497a84f7b5d89caa6dda6d3060567dfda
Reviewed-on: https://chromium-review.googlesource.com/543161
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#46742}
2017-07-18 16:14:29 +00:00

1025 lines
14 KiB
Plaintext
Raw Blame History

Checks possible break locations.
Running test: testEval
break at:
function testEval() {
#eval('// comment only');
eval('// comment only\n');
break at:
// comment onl#y
break at:
eval('// comment only');
#eval('// comment only\n');
}
break at:
// comment only#
break at:
eval('// comment only\n');
#}
Running test: testProcedure
break at:
function testProcedure() {
#procedure();
}
break at:
function procedure() {
var a = #1;
var b = 2;
break at:
var a = 1;
var b = #2;
}
break at:
var b = 2;
#}
break at:
procedure();
#}
Running test: testIf
break at:
var a;
if (true) #a = true;
if (!a) {
break at:
if (true) a = true;
#if (!a) {
a = true;
break at:
} else {
#a = false;
}
break at:
}
#if (returnTrue()) {
a = false;
break at:
function returnTrue() {
#return true;
}
break at:
function returnTrue() {
return true;#
}
break at:
if (returnTrue()) {
#a = false;
} else {
break at:
}
#}
Running test: testEmptyFunction
break at:
function testEmptyFunction() {
#emptyFunction();
}
break at:
function emptyFunction() {#}
break at:
emptyFunction();
#}
Running test: testCallArguments
break at:
function testCallArguments() {
#twoArguments(emptyFunction(), emptyFunction());
}
break at:
function emptyFunction() {#}
break at:
function testCallArguments() {
twoArguments(emptyFunction(), #emptyFunction());
}
break at:
function emptyFunction() {#}
break at:
function testCallArguments() {
#twoArguments(emptyFunction(), emptyFunction());
}
break at:
function twoArguments(a1, a2) {
#}
break at:
twoArguments(emptyFunction(), emptyFunction());
#}
Running test: testNested
break at:
}
#nested1();
}
break at:
}
return #nested2();
}
break at:
}
#nested3();
return;
break at:
function nested3() {
#}
nested3();
break at:
nested3();
#return;
}
break at:
nested3();
return;#
}
break at:
}
return nested2();#
}
break at:
nested1();
#}
Running test: testCallAtReturn
break at:
function testCallAtReturn() {
#return returnCall();
}
break at:
function returnCall() {
#return return42();
}
break at:
function return42() {
#return 42;
}
break at:
function return42() {
return 42;#
}
break at:
function returnCall() {
return return42();#
}
break at:
function testCallAtReturn() {
return returnCall();#
}
Running test: testWith
break at:
function testWith() {
#with (returnObject()) {
foo();
break at:
function returnObject() {
#return ({ foo: () => 42 });
}
break at:
function returnObject() {
return ({ foo: () => 42 });#
}
break at:
with (returnObject()) {
#foo();
}
break at:
function returnObject() {
return ({ foo: () => #42 });
}
break at:
function returnObject() {
return ({ foo: () => 42# });
}
break at:
}
#with({}) {
return;
break at:
with({}) {
#return;
}
break at:
with({}) {
return;#
}
Running test: testForLoop
break at:
function testForLoop() {
for (var i = #0; i < 1; ++i) {}
for (var i = 0; i < 1; ++i) i;
break at:
function testForLoop() {
for (var i = 0; i #< 1; ++i) {}
for (var i = 0; i < 1; ++i) i;
break at:
function testForLoop() {
for (var i = 0; i < 1; ++#i) {}
for (var i = 0; i < 1; ++i) i;
break at:
function testForLoop() {
for (var i = 0; i #< 1; ++i) {}
for (var i = 0; i < 1; ++i) i;
break at:
for (var i = 0; i < 1; ++i) {}
for (var i = #0; i < 1; ++i) i;
for (var i = 0; i < 0; ++i) {}
break at:
for (var i = 0; i < 1; ++i) {}
for (var i = 0; i #< 1; ++i) i;
for (var i = 0; i < 0; ++i) {}
break at:
for (var i = 0; i < 1; ++i) {}
for (var i = 0; i < 1; ++#i) i;
for (var i = 0; i < 0; ++i) {}
break at:
for (var i = 0; i < 1; ++i) {}
for (var i = 0; i #< 1; ++i) i;
for (var i = 0; i < 0; ++i) {}
break at:
for (var i = 0; i < 1; ++i) i;
for (var i = #0; i < 0; ++i) {}
}
break at:
for (var i = 0; i < 1; ++i) i;
for (var i = 0; i #< 0; ++i) {}
}
break at:
for (var i = 0; i < 0; ++i) {}
#}
Running test: testForOfLoop
break at:
function testForOfLoop() {
for (var k of #[]) {}
for (var k of [1]) k;
break at:
function testForOfLoop() {
for (var #k of []) {}
for (var k of [1]) k;
break at:
for (var k of []) {}
for (var k of #[1]) k;
var a = [];
break at:
for (var k of []) {}
for (var #k of [1]) k;
var a = [];
break at:
for (var k of []) {}
for (var k of [1]) #k;
var a = [];
break at:
for (var k of []) {}
for (var #k of [1]) k;
var a = [];
break at:
for (var k of [1]) k;
var a = #[];
for (var k of a) {}
break at:
var a = [];
for (var k of #a) {}
}
break at:
var a = [];
for (var #k of a) {}
}
break at:
for (var k of a) {}
#}
Running test: testForInLoop
break at:
function testForInLoop() {
var o = #{};
for (var k in o) {}
break at:
var o = {};
for (var k in #o) {}
for (var k in o) k;
break at:
var o = {};
for (var #k in o) {}
for (var k in o) k;
break at:
for (var k in o) {}
for (var k in #o) k;
for (var k in { a:1 }) {}
break at:
for (var k in o) {}
for (var #k in o) k;
for (var k in { a:1 }) {}
break at:
for (var k in o) k;
for (var k in #{ a:1 }) {}
for (var k in { a:1 }) k;
break at:
for (var k in o) k;
for (var #k in { a:1 }) {}
for (var k in { a:1 }) k;
break at:
for (var k in { a:1 }) {}
for (var k in #{ a:1 }) k;
}
break at:
for (var k in { a:1 }) {}
for (var #k in { a:1 }) k;
}
break at:
for (var k in { a:1 }) {}
for (var k in { a:1 }) #k;
}
break at:
for (var k in { a:1 }) {}
for (var #k in { a:1 }) k;
}
break at:
for (var k in { a:1 }) k;
#}
Running test: testSimpleExpressions
break at:
1 + 2 + 3;
var a = #1;
++a;
break at:
var a = 1;
#++a;
a--;
break at:
++a;
#a--;
}
break at:
a--;
#}
Running test: testGetter
break at:
function testGetter() {
#getterFoo();
}
break at:
Object.defineProperty(this, 'getterFoo', {
get: () => #return42
});
break at:
Object.defineProperty(this, 'getterFoo', {
get: () => return42#
});
break at:
function testGetter() {
#getterFoo();
}
break at:
function return42() {
#return 42;
}
break at:
function return42() {
return 42;#
}
break at:
getterFoo();
#}
Running test: testChainedCalls
break at:
function testChainedCalls() {
#obj.foo().boo()();
}
break at:
var obj = {
foo: () => (#{
boo: () => return42
break at:
boo: () => return42
})#
};
break at:
function testChainedCalls() {
obj.foo().#boo()();
}
break at:
foo: () => ({
boo: () => #return42
})
break at:
foo: () => ({
boo: () => return42#
})
break at:
function testChainedCalls() {
obj.foo().boo()#();
}
break at:
function return42() {
#return 42;
}
break at:
function return42() {
return 42;#
}
break at:
obj.foo().boo()();
#}
Running test: testChainedWithNative
break at:
function testChainedWithNative() {
#Array.from([1]).concat([2]).map(v => v * 2);
}
break at:
function testChainedWithNative() {
Array.from([1]).concat([2]).map(v => v #* 2);
}
break at:
function testChainedWithNative() {
Array.from([1]).concat([2]).map(v => v * 2#);
}
break at:
function testChainedWithNative() {
Array.from([1]).concat([2]).map(v => v #* 2);
}
break at:
function testChainedWithNative() {
Array.from([1]).concat([2]).map(v => v * 2#);
}
break at:
Array.from([1]).concat([2]).map(v => v * 2);
#}
Running test: testPromiseThen
break at:
function testPromiseThen() {
#return Promise.resolve().then(v => v * 2).then(v => v * 2);
}
break at:
function testPromiseThen() {
return Promise.resolve().then(v => v * 2).then(v => v * 2);#
}
Running test: testSwitch
break at:
function testSwitch() {
for (var i = #0; i < 3; ++i) {
switch(i) {
break at:
function testSwitch() {
for (var i = 0; i #< 3; ++i) {
switch(i) {
break at:
for (var i = 0; i < 3; ++i) {
#switch(i) {
case 0: continue;
break at:
switch(i) {
case 0: #continue;
case 1: return42(); break;
break at:
function testSwitch() {
for (var i = 0; i < 3; ++#i) {
switch(i) {
break at:
function testSwitch() {
for (var i = 0; i #< 3; ++i) {
switch(i) {
break at:
for (var i = 0; i < 3; ++i) {
#switch(i) {
case 0: continue;
break at:
case 0: continue;
case 1: #return42(); break;
default: return;
break at:
function return42() {
#return 42;
}
break at:
function return42() {
return 42;#
}
break at:
case 0: continue;
case 1: return42(); #break;
default: return;
break at:
function testSwitch() {
for (var i = 0; i < 3; ++#i) {
switch(i) {
break at:
function testSwitch() {
for (var i = 0; i #< 3; ++i) {
switch(i) {
break at:
for (var i = 0; i < 3; ++i) {
#switch(i) {
case 0: continue;
break at:
case 1: return42(); break;
default: #return;
}
break at:
case 1: return42(); break;
default: return;#
}
Running test: testGenerator
break at:
function testGenerator() {
var gen = #idMaker();
return42();
break at:
function* idMaker() {
#yield 1;
yield 2;
break at:
gen.next().value;
#debugger;
gen.next().value;
break at:
debugger;
gen.#next().value;
return42();
break at:
yield 1;
#yield 2;
yield 3;
break at:
yield 2;
#yield 3;
}
break at:
yield 3;
#}
break at:
gen.next().value;
#}
Running test: testCaughtException
break at:
try {
#throwException()
} catch (e) {
break at:
function throwException() {
#throw new Error();
}
break at:
} catch (e) {
#return;
}
break at:
} catch (e) {
return;#
}
Running test: testClasses
break at:
}
#new Lion().speak();
}
break at:
constructor(name) {
#super(name);
}
break at:
constructor(name) {
#this.name = name;
}
break at:
this.name = name;
#}
break at:
super(name);
#}
break at:
}
new Lion().#speak();
}
break at:
speak() {
#super.speak();
}
break at:
speak() {
#}
}
break at:
super.speak();
#}
}
break at:
new Lion().speak();
#}
Running test: testAsyncAwait
break at:
async function testAsyncAwait() {
#await asyncFoo();
await awaitBoo();
break at:
async function asyncFoo() {
#await Promise.resolve().then(v => v * 2);
return42();
break at:
function return42() {
#return 42;
}
break at:
function return42() {
return 42;#
}
break at:
async function asyncBoo() {
#await Promise.resolve();
}
Running test: testPromiseAsyncWithCode
break at:
var nextTest;
var testPromise = #new Promise(resolve => nextTest = resolve);
async function main() {
break at:
var nextTest;
var testPromise = new Promise(resolve => nextTest #= resolve);
async function main() {
break at:
var nextTest;
var testPromise = new Promise(resolve => nextTest = resolve#);
async function main() {
break at:
}
#main();
return testPromise;
break at:
}
#setTimeout(returnCall, 0);
await foo();
break at:
setTimeout(returnCall, 0);
await #foo();
await foo();
break at:
var resolveNested;
var p = #new Promise(resolve => resolveNested = resolve);
setTimeout(resolveNested, 0);
break at:
var resolveNested;
var p = new Promise(resolve => resolveNested #= resolve);
setTimeout(resolveNested, 0);
break at:
var resolveNested;
var p = new Promise(resolve => resolveNested = resolve#);
setTimeout(resolveNested, 0);
break at:
var p = new Promise(resolve => resolveNested = resolve);
#setTimeout(resolveNested, 0);
await p;
break at:
setTimeout(resolveNested, 0);
#await p;
}
break at:
var resolveNested;
var p = #new Promise(resolve => resolveNested = resolve);
setTimeout(resolveNested, 0);
break at:
var resolveNested;
var p = new Promise(resolve => resolveNested #= resolve);
setTimeout(resolveNested, 0);
break at:
var resolveNested;
var p = new Promise(resolve => resolveNested = resolve#);
setTimeout(resolveNested, 0);
break at:
var p = new Promise(resolve => resolveNested = resolve);
#setTimeout(resolveNested, 0);
await p;
break at:
setTimeout(resolveNested, 0);
#await p;
}
Running test: testPromiseComplex
break at:
var nextTest;
var testPromise = #new Promise(resolve => nextTest = resolve);
async function main() {
break at:
var nextTest;
var testPromise = new Promise(resolve => nextTest #= resolve);
async function main() {
break at:
var nextTest;
var testPromise = new Promise(resolve => nextTest = resolve#);
async function main() {
break at:
}
#main();
return testPromise;
break at:
}
var x = #1;
var y = 2;
break at:
var x = 1;
var y = #2;
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
break at:
var y = 2;
#returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
nextTest();
break at:
function emptyFunction() {#}
break at:
var y = 2;
returnFunction(emptyFunction(), x++, --y, x => 2 * x, #returnCall())().a = await foo((a => 2 *a)(5));
nextTest();
break at:
function returnCall() {
#return return42();
}
break at:
function return42() {
#return 42;
}
break at:
function return42() {
return 42;#
}
break at:
function returnCall() {
return return42();#
}
break at:
var y = 2;
#returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
nextTest();
break at:
function returnFunction() {
#return returnObject;
}
break at:
function returnFunction() {
return returnObject;#
}
break at:
var y = 2;
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())#().a = await foo((a => 2 *a)(5));
nextTest();
break at:
function returnObject() {
#return ({ foo: () => 42 });
}
break at:
function returnObject() {
return ({ foo: () => 42 });#
}
break at:
var y = 2;
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)#(5));
nextTest();
break at:
var y = 2;
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 #*a)(5));
nextTest();
break at:
var y = 2;
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a#)(5));
nextTest();
break at:
var y = 2;
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await #foo((a => 2 *a)(5));
nextTest();
break at:
async function foo() {
#await Promise.resolve();
return 42;
Reference in New Issue View Git Blame Copy Permalink