1//===- llvm/CallingConv.h - LLVM Calling Conventions ------------*- C++ -*-===// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7//===----------------------------------------------------------------------===// 9// This file defines LLVM's set of calling conventions. 11//===----------------------------------------------------------------------===// 13#ifndef LLVM_IR_CALLINGCONV_H 14#define LLVM_IR_CALLINGCONV_H 18/// CallingConv Namespace - This namespace contains an enum with a value for 19/// the well-known calling conventions. 23 /// LLVM IR allows to use arbitrary numbers as calling convention identifiers. 26 /// A set of enums which specify the assigned numeric values for known llvm 27 /// calling conventions. 28 /// LLVM Calling Convention Representation 30 /// The default llvm calling convention, compatible with C. This convention 31 /// is the only one that supports varargs calls. As with typical C calling 32 /// conventions, the callee/caller have to tolerate certain amounts of 33 /// prototype mismatch. 36// Generic LLVM calling conventions. None of these support varargs calls, 37// and all assume that the caller and callee prototype exactly match. 39 /// Attempts to make calls as fast as possible (e.g. by passing things in 43 /// Attempts to make code in the caller as efficient as possible under the 44 /// assumption that the call is not commonly executed. As such, these calls 45 /// often preserve all registers so that the call does not break any live 46 /// ranges in the caller side. 49 /// Used by the Glasgow Haskell Compiler (GHC). 52 /// Used by the High-Performance Erlang Compiler (HiPE). 55 /// OBSOLETED - Used for stack based JavaScript calls 58 /// Used for dynamic register based calls (e.g. stackmap and patchpoint 62 /// Used for runtime calls that preserves most registers. 65 /// Used for runtime calls that preserves (almost) all registers. 68 /// Calling convention for Swift. 71 /// Used for access functions. 74 /// Attemps to make calls as fast as possible while guaranteeing that tail 75 /// call optimization can always be performed. 78 /// Special calling convention on Windows for calling the Control Guard 79 /// Check ICall funtion. The function takes exactly one argument (address of 80 /// the target function) passed in the first argument register, and has no 81 /// return value. All register values are preserved. 84 /// This follows the Swift calling convention in how arguments are passed 85 /// but guarantees tail calls will be made by making the callee clean up 89 /// Used for runtime calls that preserves none general registers. 92 /// This is the start of the target-specific calling conventions, e.g. 93 /// fastcall and thiscall on X86. 96 /// stdcall is mostly used by the Win32 API. It is basically the same as the 97 /// C convention with the difference in that the callee is responsible for 98 /// popping the arguments from the stack. 101 /// 'fast' analog of X86_StdCall. Passes first two arguments in ECX:EDX 102 /// registers, others - via stack. Callee is responsible for stack cleaning. 105 /// ARM Procedure Calling Standard (obsolete, but still used on some 109 /// ARM Architecture Procedure Calling Standard calling convention (aka 110 /// EABI). Soft float variant. 113 /// Same as ARM_AAPCS, but uses hard floating point ABI. 116 /// Used for MSP430 interrupt routines. 119 /// Similar to X86_StdCall. Passes first argument in ECX, others via stack. 120 /// Callee is responsible for stack cleaning. MSVC uses this by default for 121 /// methods in its ABI. 124 /// Call to a PTX kernel. Passes all arguments in parameter space. 127 /// Call to a PTX device function. Passes all arguments in register or 131 /// Used for SPIR non-kernel device functions. No lowering or expansion of 132 /// arguments. Structures are passed as a pointer to a struct with the 133 /// byval attribute. Functions can only call SPIR_FUNC and SPIR_KERNEL 134 /// functions. Functions can only have zero or one return values. Variable 135 /// arguments are not allowed, except for printf. How arguments/return 136 /// values are lowered are not specified. Functions are only visible to the 140 /// Used for SPIR kernel functions. Inherits the restrictions of SPIR_FUNC, 141 /// except it cannot have non-void return values, it cannot have variable 142 /// arguments, it can also be called by the host or it is externally 146 /// Used for Intel OpenCL built-ins. 149 /// The C convention as specified in the x86-64 supplement to the System V 150 /// ABI, used on most non-Windows systems. 153 /// The C convention as implemented on Windows/x86-64 and AArch64. It 154 /// differs from the more common \c X86_64_SysV convention in a number of 155 /// ways, most notably in that XMM registers used to pass arguments are 156 /// shadowed by GPRs, and vice versa. On AArch64, this is identical to the 157 /// normal C (AAPCS) calling convention for normal functions, but floats are 158 /// passed in integer registers to variadic functions. 161 /// MSVC calling convention that passes vectors and vector aggregates in SSE 165 /// Placeholders for HHVM calling conventions (deprecated, removed). 169 /// x86 hardware interrupt context. Callee may take one or two parameters, 170 /// where the 1st represents a pointer to hardware context frame and the 2nd 171 /// represents hardware error code, the presence of the later depends on the 172 /// interrupt vector taken. Valid for both 32- and 64-bit subtargets. 175 /// Used for AVR interrupt routines. 178 /// Used for AVR signal routines. 181 /// Used for special AVR rtlib functions which have an "optimized" 182 /// convention to preserve registers. 185 /// Used for Mesa vertex shaders, or AMDPAL last shader stage before 186 /// rasterization (vertex shader if tessellation and geometry are not in 187 /// use, or otherwise copy shader if one is needed). 190 /// Used for Mesa/AMDPAL geometry shaders. 193 /// Used for Mesa/AMDPAL pixel shaders. 196 /// Used for Mesa/AMDPAL compute shaders. 199 /// Used for AMDGPU code object kernels. 202 /// Register calling convention used for parameters transfer optimization 205 /// Used for Mesa/AMDPAL hull shaders (= tessellation control shaders). 208 /// Used for special MSP430 rtlib functions which have an "optimized" 209 /// convention using additional registers. 212 /// Used for AMDPAL vertex shader if tessellation is in use. 215 /// Used for AMDPAL shader stage before geometry shader if geometry is in 216 /// use. So either the domain (= tessellation evaluation) shader if 217 /// tessellation is in use, or otherwise the vertex shader. 220 /// Used between AArch64 Advanced SIMD functions 223 /// Used between AArch64 SVE functions 226 /// For emscripten __invoke_* functions. The first argument is required to 227 /// be the function ptr being indirectly called. The remainder matches the 228 /// regular calling convention. 231 /// Used for AMD graphics targets. 234 /// Used for M68k interrupt routines. 237 /// Preserve X0-X13, X19-X29, SP, Z0-Z31, P0-P15. 240 /// Preserve X2-X15, X19-X29, SP, Z0-Z31, P0-P15. 243 /// Used on AMDGPUs to give the middle-end more control over argument 247 /// Used on AMDGPUs to give the middle-end more control over argument 248 /// placement. Preserves active lane values for input VGPRs. 251 /// Used for M68k rtd-based CC (similar to X86's stdcall). 254 /// Used by GraalVM. Two additional registers are reserved. 257 /// Calling convention used in the ARM64EC ABI to implement calls between 258 /// x64 code and thunks. This is basically the x64 calling convention using 259 /// ARM64 register names. The first parameter is mapped to x9. 262 /// Calling convention used in the ARM64EC ABI to implement calls between 263 /// ARM64 code and thunks. This is just the ARM64 calling convention, 264 /// except that the first parameter is mapped to x9. 267 /// Calling convention used for RISC-V V-extension. 270 /// Preserve X1-X15, X19-X29, SP, Z0-Z31, P0-P15. 273 /// The highest possible ID. Must be some 2^k - 1. 277}
// end namespace CallingConv 279}
// end namespace llvm 281#endif// LLVM_IR_CALLINGCONV_H @ ARM64EC_Thunk_Native
Calling convention used in the ARM64EC ABI to implement calls between ARM64 code and thunks.
@ AArch64_VectorCall
Used between AArch64 Advanced SIMD functions.
@ X86_64_SysV
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
@ RISCV_VectorCall
Calling convention used for RISC-V V-extension.
@ AMDGPU_CS
Used for Mesa/AMDPAL compute shaders.
@ M68k_INTR
Used for M68k interrupt routines.
@ AMDGPU_VS
Used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (vertex shader if tess...
@ MSP430_BUILTIN
Used for special MSP430 rtlib functions which have an "optimized" convention using additional registe...
@ AVR_SIGNAL
Used for AVR signal routines.
@ HiPE
Used by the High-Performance Erlang Compiler (HiPE).
@ Swift
Calling convention for Swift.
@ AMDGPU_KERNEL
Used for AMDGPU code object kernels.
@ MaxID
The highest possible ID. Must be some 2^k - 1.
@ AArch64_SVE_VectorCall
Used between AArch64 SVE functions.
@ ARM_APCS
ARM Procedure Calling Standard (obsolete, but still used on some targets).
@ CFGuard_Check
Special calling convention on Windows for calling the Control Guard Check ICall funtion.
@ AVR_INTR
Used for AVR interrupt routines.
@ PreserveMost
Used for runtime calls that preserves most registers.
@ AnyReg
OBSOLETED - Used for stack based JavaScript calls.
@ AMDGPU_Gfx
Used for AMD graphics targets.
@ DUMMY_HHVM
Placeholders for HHVM calling conventions (deprecated, removed).
@ AMDGPU_CS_ChainPreserve
Used on AMDGPUs to give the middle-end more control over argument placement.
@ AMDGPU_HS
Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
@ ARM_AAPCS
ARM Architecture Procedure Calling Standard calling convention (aka EABI).
@ AMDGPU_GS
Used for Mesa/AMDPAL geometry shaders.
@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2
Preserve X2-X15, X19-X29, SP, Z0-Z31, P0-P15.
@ CXX_FAST_TLS
Used for access functions.
@ X86_INTR
x86 hardware interrupt context.
@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0
Preserve X0-X13, X19-X29, SP, Z0-Z31, P0-P15.
@ WASM_EmscriptenInvoke
For emscripten __invoke_* functions.
@ AMDGPU_CS_Chain
Used on AMDGPUs to give the middle-end more control over argument placement.
@ AVR_BUILTIN
Used for special AVR rtlib functions which have an "optimized" convention to preserve registers.
@ GHC
Used by the Glasgow Haskell Compiler (GHC).
@ AMDGPU_PS
Used for Mesa/AMDPAL pixel shaders.
@ Cold
Attempts to make code in the caller as efficient as possible under the assumption that the call is no...
@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X1
Preserve X1-X15, X19-X29, SP, Z0-Z31, P0-P15.
@ X86_ThisCall
Similar to X86_StdCall.
@ PTX_Device
Call to a PTX device function.
@ SPIR_KERNEL
Used for SPIR kernel functions.
@ PreserveAll
Used for runtime calls that preserves (almost) all registers.
@ X86_StdCall
stdcall is mostly used by the Win32 API.
@ FirstTargetCC
This is the start of the target-specific calling conventions, e.g.
@ SPIR_FUNC
Used for SPIR non-kernel device functions.
@ Fast
Attempts to make calls as fast as possible (e.g.
@ MSP430_INTR
Used for MSP430 interrupt routines.
@ X86_VectorCall
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
@ Intel_OCL_BI
Used for Intel OpenCL built-ins.
@ PreserveNone
Used for runtime calls that preserves none general registers.
@ AMDGPU_ES
Used for AMDPAL shader stage before geometry shader if geometry is in use.
@ Tail
Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...
@ Win64
The C convention as implemented on Windows/x86-64 and AArch64.
@ PTX_Kernel
Call to a PTX kernel. Passes all arguments in parameter space.
@ SwiftTail
This follows the Swift calling convention in how arguments are passed but guarantees tail calls will ...
@ GRAAL
Used by GraalVM. Two additional registers are reserved.
@ AMDGPU_LS
Used for AMDPAL vertex shader if tessellation is in use.
@ ARM_AAPCS_VFP
Same as ARM_AAPCS, but uses hard floating point ABI.
@ ARM64EC_Thunk_X64
Calling convention used in the ARM64EC ABI to implement calls between x64 code and thunks.
@ X86_RegCall
Register calling convention used for parameters transfer optimization.
@ M68k_RTD
Used for M68k rtd-based CC (similar to X86's stdcall).
@ C
The default llvm calling convention, compatible with C.
@ X86_FastCall
'fast' analog of X86_StdCall.
This is an optimization pass for GlobalISel generic memory operations.
