[Async CC] Add constant "pointer" for async func. #34589
Merged
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
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
2 times, most recently
from
54d70ba to
be5273a
Compare
rjmccall
reviewed
Nov 5, 2020
lib/IRGen/GenCall.cpp
Outdated
| auto *sizeValue = | ||
| llvm::ConstantInt::get(IGF.IGM.Int32Ty, size.getValue()); | ||
| phiValues.push_back({staticSizeBlock, sizeValue}); | ||
| auto *ptr = functionPointer.getRawPointer(); |
There was a problem hiding this comment.
You need logic for pointer authentication here.
lib/IRGen/GenCall.cpp
Outdated
| if (kind == KindTy::AsyncFunctionPointer) { | ||
| assert(fnType->getRepresentation() != SILFunctionTypeRepresentation::Thick); | ||
| } | ||
| return forDirect(kind, fnPtr, IGM.getSignature(fnType)); |
There was a problem hiding this comment.
This is determinable from the function type, right?
Should we lay the groundwork to make direct calls actually be direct in IR and just also record the context-size pointer?
There was a problem hiding this comment.
Something like this?
// Have to dig the size out of the AsyncFunctionPointer so that it can be rewritten downstream
%afp = `AsyncFunctionPointer(callee)`
%size_addr = getelementptr %afp, 0, 1
%size = load %size_addr
%context = call @swift_task_alloc(%task, %size)
// But we don't have to dig the function pointer out of the AsyncFunctionPointer because we already know what it is
call @callee(%task, %executor, %context)
lib/IRGen/GenCall.cpp
Outdated
| switch (Kind) { | ||
| case KindTy::Function: | ||
| return Value; | ||
| case KindTy::AsyncFunctionPointer: |
There was a problem hiding this comment.
Pointer auth logic required.
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
4 times, most recently
from
b061dcb to
2fef32a
Compare
|
@swift-ci please test |
|
@swift-ci please clean test windows platform |
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
from
2fef32a to
0280141
Compare
|
@swift-ci please test |
|
@swift-ci please clean test windows |
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
from
0280141 to
27f1d5b
Compare
|
@swift-ci please test |
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
from
27f1d5b to
4827118
Compare
|
@swift-ci please test |
|
Build failed |
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
from
4827118 to
fb6045b
Compare
|
@swift-ci please test |
|
@swift-ci please clean test windows |
|
Build failed |
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
from
fb6045b to
3470f75
Compare
|
@swift-ci please test |
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
3 times, most recently
from
67d9e21 to
ad74809
Compare
|
@swift-ci please test |
1 similar comment
|
@swift-ci please test |
ClassMetadataLayout::getOffsett -> ClassMetadataLayout::getOffset
Two LinkEntities are needed to enable the construction during both IRGen and TBDGen.
In order to call async functions, instances of the AsyncFunctionPointer struct must be used. If those functions are exported from a module, the AsyncFunctionPointer by means of which the function is to be called must be exported as well. For now, the symbol is exported by manually appending the relevant suffix to the mangled name of the function.
An AsyncFunctionPointer, defined in Task.h, is a struct consisting of two i32s: (1) the relative address of the async function and (2) the size of the async context to be allocated when calling that function. Here, such structs are emitted for every async SILFunction that is emitted.
While the pointer auth details are worked out, to unblock other work, disable the tests on arm64e where they will fail until those details are worked out.
nate-chandler
force-pushed
the
concurrency/irgen/function-constants
branch
from
ae4dbe3 to
6962874
Compare
|
@swift-ci please test |
|
Build failed |
|
Build failed |
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.
An AsyncFunctionPointer, defined in Task.h, is a struct consisting of two i32s: (1) the relative address of the async function and (2) the size of the async context to be allocated when calling that function.
Here, such structs are emitted for every async SILFunction that is emitted. Furthermore, pointers to these new structs rather than pointers directly to async functions are passed around. The async context size is now read out of these function pointers and used to allocate the async context. This will enable the size constants to be rewritten by an LLVM pass with the ideal storage space to minimize additional allocations.
The following tasks need to be completed before merge:
The following related task will be completed in follow-on PRs: