[cherry-pick][lldb][swift] Fix StackID comparisons to enable stepping out of async functions #9211
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
The optimization in swiftlang#7877 accidentally changed the default answer for this function. It's important to default to "On Stack" when we don't know, because that's where most CFAs live, and because we don't want to trigger the expensive heap comparisons unless we're absolutely sure the CFA is on the heap. (cherry picked from commit 57757e9)
Currently, if we're comparing a StackID on the stack with one StackID on the heap, we perform a special kind of IsYounger comparison. However, if `IsYounger(A, b)` returns true, it must be the case that `IsYounger(B, A)` returns false. But this is not necessarily the case today because, before this patch, we would fallback to the traditional "stack" comparison, which is wrong if one of the StackIDs is on the heap. (cherry picked from commit 349d906)
For two StackIDs whose CFAs are on the heap, i.e., they are both async frames, we can decide which one is younger by finding one async context in the continuation chain of the other. A lot of stepping algorithms rely on frame comparisons. In particular, this patch fixes stepping out of async functions, and makes strides towards fixing other stepping algorithms. The explanation below is not needed to understand this patch, but it sheds some light into why the most common kind of step out fails. Consider the case where a breakpoint was set inside some async function, the program hit that breakpoint, and then a "step out" operation is performed. This is a very common use case. The thread plan looks like this: 0. Single step past breakpoint. 1. Step out LLDB performs a single step, and thread plan 0 says "continue running, I'm done". Before continuing program execution, LLDB asks all thread plans, in this case there's only the step out plan, if it should stop. To answer the "should stop" question, the step out plan compares the current frame (which is the same as when step out was pushed, since LLDB has only performed a single step so far) with its target frame (which is just one frame above). In this scenario, the current frame is async, and so the parent frame must also be async. The StepOut plan is going to compare two async StackIDs. Using the incorrect comparison, StepOut concludes the current frame is _older_ than the target frame. In other words, the program reached an older frame without ever stopping on the target frame. Something weird must have happened, and the plan concludes it is done. (cherry picked from commit 8d7935d)
|
Cherry-pick from #9162 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.