Tracking Issue for the `gpu-kernel` ABI

The feature gate for the issue is #![feature(abi_gpu_kernel)].

The extern "gpu-kernel" calling convention represents the entry points exposed to the host, which are then called to actually execute the GPU kernel. Functions built for a GPU target are instead "device functions". Device functions must not call these host functions (and LLVM will emit a compilation error if it is attempted for some targets).

It is implemented for the following targets

• nvptx64 (translating to the ptx_kernel calling convention in LLVM)
• amdgpu (translating to the amdgpu_kernel calling convention in LLVM)

About tracking issues

Tracking issues are used to record the overall progress of implementation.
They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions.
A tracking issue is however not meant for large scale discussion, questions, or bug reports about a feature.
Instead, open a dedicated issue for the specific matter and add the relevant feature gate label.
Discussion comments will get marked as off-topic or deleted.
Repeated discussions on the tracking issue may lead to the tracking issue getting locked.

Steps

• RFC
• Adjust documentation (see instructions on rustc-dev-guide)
• Formatting for new syntax has been added to the Style Guide (nightly-style-procedure)
• Stabilization PR (see instructions on rustc-dev-guide)

Unresolved Questions

• May need a story for how to handle breaking changes in ABIs (esp. re: ptx_kernel)
• This may want to be extern "device-kernel" instead?
• May want to address or dismiss the question of SPIRV's OpEntryPoint
• What function signatures are actually valid? LLVM generally doesn't try to validate these, so we must determine that ourselves.
• Devices shouldn't be able to call these functions, but who can?
• Should these functions always be unsafe to call? If so, making them uncallable from device code may be redundant (but "my unsafe generated an LLVM error" would be kinda unsettling, even if we define it as UB)

Implementation history

• Implement the ABI https://github.com/rust-lang/rust/pull/135047
• Prevent safely calling extern "gpu-kernel" functions when compiling for GPU targets: #149991
• Document valid function signatures
  • Must have no return value () or !
• Bar invalid function signatures: #149991

Start with implementation PR #135047 and the remaining work tracked in #149991, then review the linked stabilization and documentation guidance. Done requires resolving the ABI design questions, documenting valid signatures and callability, and completing the RFC, documentation, style, and stabilization checklist items.