AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
7b7df7db4d
v8/test/inspector/debugger/stepping-tail-call-expected.txt

175 lines
2.5 KiB
Plaintext
Raw Normal View History

[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Checks stepping over tail calls.
Running test: testStepOver
f (:2:14)
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
function f(x) {
if (x == 2) #debugger;
if (x-- > 0) return f(x);
Debugger.stepOver called
f (:3:2)
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
if (x == 2) debugger;
#if (x-- > 0) return f(x);
}
Debugger.stepOver called
f (:3:15)
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
if (x == 2) debugger;
if (x-- > 0) #return f(x);
}
Debugger.stepOver called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOver called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOver called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
f (:3:22)
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOver called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOver called
Reland "[inspector] fixed location of top level function return" This is a reland of 4363a693352e75a919cf4524d1b3b17b204571c0 Original change's description: > [inspector] fixed location of top level function return > > We should pass false as has_braces argument to create FunctionLiteral > for top level function. > > R=dgozman@chromium.org,bmeurer@chromium.org > TBR=bmeurer@chromium.org > > Bug: none > Change-Id: I397f31b562d32c71f3a12bfc9ceeed16c367aa80 > Reviewed-on: https://chromium-review.googlesource.com/1098018 > Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> > Reviewed-by: Dmitry Gozman <dgozman@chromium.org> > Reviewed-by: Yang Guo <yangguo@chromium.org> > Cr-Commit-Position: refs/heads/master@{#53769} TBR=dgozman@chromium.org Bug: v8:7858 Change-Id: Ie636bc101f9d29d9d40bd10b96e62da6505c2734 Reviewed-on: https://chromium-review.googlesource.com/1104497 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Cr-Commit-Position: refs/heads/master@{#53808}
2018-06-12 21:57:52 +00:00
(anonymous) (:6:0)
f(5);
#
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.resume called
Running test: testStepOut
f (:2:14)
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
function f(x) {
if (x == 2) #debugger;
if (x-- > 0) return f(x);
Debugger.stepOut called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOut called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
f (:3:22)
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOut called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOut called
Reland "[inspector] fixed location of top level function return" This is a reland of 4363a693352e75a919cf4524d1b3b17b204571c0 Original change's description: > [inspector] fixed location of top level function return > > We should pass false as has_braces argument to create FunctionLiteral > for top level function. > > R=dgozman@chromium.org,bmeurer@chromium.org > TBR=bmeurer@chromium.org > > Bug: none > Change-Id: I397f31b562d32c71f3a12bfc9ceeed16c367aa80 > Reviewed-on: https://chromium-review.googlesource.com/1098018 > Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> > Reviewed-by: Dmitry Gozman <dgozman@chromium.org> > Reviewed-by: Yang Guo <yangguo@chromium.org> > Cr-Commit-Position: refs/heads/master@{#53769} TBR=dgozman@chromium.org Bug: v8:7858 Change-Id: Ie636bc101f9d29d9d40bd10b96e62da6505c2734 Reviewed-on: https://chromium-review.googlesource.com/1104497 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Cr-Commit-Position: refs/heads/master@{#53808}
2018-06-12 21:57:52 +00:00
(anonymous) (:6:0)
f(5);
#
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.resume called
Running test: testStepOutFromReturn
f (:2:14)
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
function f(x) {
if (x == 2) #debugger;
if (x-- > 0) return f(x);
Debugger.stepOver called
f (:3:2)
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
if (x == 2) debugger;
#if (x-- > 0) return f(x);
}
Debugger.stepOver called
f (:3:15)
f (:3:22)
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
if (x == 2) debugger;
if (x-- > 0) #return f(x);
}
Debugger.stepOut called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
f (:3:22)
f (:3:22)
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOut called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
f (:3:22)
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOut called
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
f (:3:27)
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
(anonymous) (:5:0)
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
if (x == 2) debugger;
if (x-- > 0) return f(x);#
}
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.stepOut called
Reland "[inspector] fixed location of top level function return" This is a reland of 4363a693352e75a919cf4524d1b3b17b204571c0 Original change's description: > [inspector] fixed location of top level function return > > We should pass false as has_braces argument to create FunctionLiteral > for top level function. > > R=dgozman@chromium.org,bmeurer@chromium.org > TBR=bmeurer@chromium.org > > Bug: none > Change-Id: I397f31b562d32c71f3a12bfc9ceeed16c367aa80 > Reviewed-on: https://chromium-review.googlesource.com/1098018 > Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> > Reviewed-by: Dmitry Gozman <dgozman@chromium.org> > Reviewed-by: Yang Guo <yangguo@chromium.org> > Cr-Commit-Position: refs/heads/master@{#53769} TBR=dgozman@chromium.org Bug: v8:7858 Change-Id: Ie636bc101f9d29d9d40bd10b96e62da6505c2734 Reviewed-on: https://chromium-review.googlesource.com/1104497 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Cr-Commit-Position: refs/heads/master@{#53808}
2018-06-12 21:57:52 +00:00
(anonymous) (:6:0)
f(5);
#
[debugger] tuned StepNext and StepOut at return position Proposed behaviour: - StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side); - StepOut at return position go into next non-current function call. We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners). New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test): - let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another: var foo = () => 1; callAll(foo, foo, () => 2); If we break inside of first call of function foo. Then on.. ..StepNext - we're able to reach second call of function foo, ..StepOut - we're able to reach () => 2 call. - let's consider case with native function: [1,2,3].map(x => x * 2) If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call. Implementation details: - when we request break we schedule step-in function call for any step action at return position and for step-in at any position, - when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call, - when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break. Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit BUG=v8:6118,chromium:583193 R=dgozman@chromium.org,yangguo@chromium.org Review-Url: https://codereview.chromium.org/2758483002 Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
Debugger.resume called
Reference in New Issue Copy Permalink