Fix clang-tidy warning - qualify auto pointer var
Wed, Jul 7
Change variable name from TyAlignment to SpillAlignment
Jul 6 2021
Fix variable case and change auto to auto *
Use the compute type alignment for spilled values when spilling/restoring
Oh my. You are right I should have verified that when we spill that value though we use the right alignment. Because we don't. :(.
The spilled value from this test comes from trying to spill %vector_spill which is a value life across a suspend point. Because it has a value it has no alignment. It is misleading that we load the value from an alloca. It could also be the result of a computation. This test case crashes before the patch because we are assigning the abi alignment for the value '%vector_spill`.
Jul 1 2021
Jun 28 2021
Jun 23 2021
getSingleSuccessor call should be getSinglePredecessor
Jun 11 2021
Jun 10 2021
Jun 2 2021
May 29 2021
@efriedma It is critical for Swift that ‘swifttailcc’ function calls in tail position be executed in constant stack space. Guaranteed tail call opt was the reason why we added this convention.
May 28 2021
I guess that the 'in tail position' restriction cannot really be used by frontends because it has to predict that otherStuff() cannot be optimized away. So it would not buy us much other than a loss of clarity ...
notail is not hypothetical it already exists.
@rjmccall The invariant is not (edit: s/is/should not be imo/g) all swiftailcc calls need to be annotate but only calls in tail position - call followed by return.
May 27 2021
The whole point behind the swiftasynccc convention (swifttailcc in llvm; whose clang support we still have to upstream I think) is to use only constant stack space for an unbounded number of calls in tail call position. So this is an invariant in my opinion. If a frontend wants to opt out of that invariant in can annotate the call with nottail. The c frontend marks calls in tail position immediately followed by a return as musttail. The swift frontend uses musttail wherever appropriate.
Mar 9 2021
Mar 5 2021
Mar 3 2021
Feb 23 2021
Feb 22 2021
looks good to me
Feb 16 2021
Looks good to me
Feb 15 2021
Feb 12 2021
Feb 11 2021
Same patch. Lets restart testing. The previous failures all seemed very unrelated.
Feb 5 2021
Feb 4 2021
Add comment to test case.
Jan 22 2021
Jan 21 2021
Dec 22 2020
Fix clang-tidy warnings.
Dec 18 2020
Nov 16 2020
Nov 14 2020
Nov 13 2020
Update the wording of a comment.
Nov 11 2020
Use the function argument index instead of the function argument in
coro.id.async. This solves any spurious use issues.
Transfer the debug location from the suspend point to the functions called at and after the suspend point (context projection).
Yes, frontend is expected to emit a thunk that models the tail call to the function at the suspend point. This prevents code moving in between the tail call and return before coroutine splitting and allows for specifying how to perform the call (e.g pointer authentication).
Nov 10 2020
Also inline the context project function used by the resume function.
I am worried about introducing unnecessary thunks that the debugger has to step through.
Semantically, it is not needed. But without inlining here this helper dispatch function thunk will remain at O0 because inlining is not run again.
Nov 9 2020
Nov 6 2020
Hmm, those failures also occur on other PRs. I guess we don't keep this bot clean.
Nov 5 2020
No change. Retrigger tests.
Retry with clang-format. test/Other/new-pass-manager.ll passes locally
One more lint clang-tidy fix.
Fix a comment to reflect that the async context argument position is now parameterizable
Change the async function pointer's context size position
Fix Lint errors
Nov 4 2020
Nov 2 2020
Fix more lint errors
Address comments and lint formatting errors