1//===- llvm/CallingConv.h - LLVM Calling Conventions ------------*- C++ -*-===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines LLVM's set of calling conventions.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_IR_CALLINGCONV_H
14#define LLVM_IR_CALLINGCONV_H
15
16namespace llvm {
17
18/// CallingConv Namespace - This namespace contains an enum with a value for
19/// the well-known calling conventions.
20///
21namespace CallingConv {
22
23 /// LLVM IR allows to use arbitrary numbers as calling convention identifiers.
24 using ID = unsigned;
25
26 /// A set of enums which specify the assigned numeric values for known llvm
27 /// calling conventions.
28 /// LLVM Calling Convention Representation
29 enum {
30 /// C - The default llvm calling convention, compatible with C. This
31 /// convention is the only calling convention that supports varargs calls.
32 /// As with typical C calling conventions, the callee/caller have to
33 /// tolerate certain amounts of prototype mismatch.
34 C = 0,
35
36 // Generic LLVM calling conventions. None of these calling conventions
37 // support varargs calls, and all assume that the caller and callee
38 // prototype exactly match.
39
40 /// Fast - This calling convention attempts to make calls as fast as
41 /// possible (e.g. by passing things in registers).
42 Fast = 8,
43
44 // Cold - This calling convention attempts to make code in the caller as
45 // efficient as possible under the assumption that the call is not commonly
46 // executed. As such, these calls often preserve all registers so that the
47 // call does not break any live ranges in the caller side.
48 Cold = 9,
49
50 // GHC - Calling convention used by the Glasgow Haskell Compiler (GHC).
51 GHC = 10,
52
53 // HiPE - Calling convention used by the High-Performance Erlang Compiler
54 // (HiPE).
55 HiPE = 11,
56
57 // WebKit JS - Calling convention for stack based JavaScript calls
58 WebKit_JS = 12,
59
60 // AnyReg - Calling convention for dynamic register based calls (e.g.
61 // stackmap and patchpoint intrinsics).
62 AnyReg = 13,
63
64 // PreserveMost - Calling convention for runtime calls that preserves most
65 // registers.
66 PreserveMost = 14,
67
68 // PreserveAll - Calling convention for runtime calls that preserves
69 // (almost) all registers.
70 PreserveAll = 15,
71
72 // Swift - Calling convention for Swift.
73 Swift = 16,
74
75 // CXX_FAST_TLS - Calling convention for access functions.
76 CXX_FAST_TLS = 17,
77
78 /// Tail - This calling convention attemps to make calls as fast as
79 /// possible while guaranteeing that tail call optimization can always
80 /// be performed.
81 Tail = 18,
82
83 /// Special calling convention on Windows for calling the Control
84 /// Guard Check ICall funtion. The function takes exactly one argument
85 /// (address of the target function) passed in the first argument register,
86 /// and has no return value. All register values are preserved.
87 CFGuard_Check = 19,
88
89 // Target - This is the start of the target-specific calling conventions,
90 // e.g. fastcall and thiscall on X86.
91 FirstTargetCC = 64,
92
93 /// X86_StdCall - stdcall is the calling conventions mostly used by the
94 /// Win32 API. It is basically the same as the C convention with the
95 /// difference in that the callee is responsible for popping the arguments
96 /// from the stack.
97 X86_StdCall = 64,
98
99 /// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments
100 /// in ECX:EDX registers, others - via stack. Callee is responsible for
101 /// stack cleaning.
102 X86_FastCall = 65,
103
104 /// ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete,
105 /// but still used on some targets).
106 ARM_APCS = 66,
107
108 /// ARM_AAPCS - ARM Architecture Procedure Calling Standard calling
109 /// convention (aka EABI). Soft float variant.
110 ARM_AAPCS = 67,
111
112 /// ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
113 ARM_AAPCS_VFP = 68,
114
115 /// MSP430_INTR - Calling convention used for MSP430 interrupt routines.
116 MSP430_INTR = 69,
117
118 /// X86_ThisCall - Similar to X86_StdCall. Passes first argument in ECX,
119 /// others via stack. Callee is responsible for stack cleaning. MSVC uses
120 /// this by default for methods in its ABI.
121 X86_ThisCall = 70,
122
123 /// PTX_Kernel - Call to a PTX kernel.
124 /// Passes all arguments in parameter space.
125 PTX_Kernel = 71,
126
127 /// PTX_Device - Call to a PTX device function.
128 /// Passes all arguments in register or parameter space.
129 PTX_Device = 72,
130
131 /// SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
132 /// No lowering or expansion of arguments.
133 /// Structures are passed as a pointer to a struct with the byval attribute.
134 /// Functions can only call SPIR_FUNC and SPIR_KERNEL functions.
135 /// Functions can only have zero or one return values.
136 /// Variable arguments are not allowed, except for printf.
137 /// How arguments/return values are lowered are not specified.
138 /// Functions are only visible to the devices.
139 SPIR_FUNC = 75,
140
141 /// SPIR_KERNEL - Calling convention for SPIR kernel functions.
142 /// Inherits the restrictions of SPIR_FUNC, except
143 /// Cannot have non-void return values.
144 /// Cannot have variable arguments.
145 /// Can also be called by the host.
146 /// Is externally visible.
147 SPIR_KERNEL = 76,
148
149 /// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins
150 Intel_OCL_BI = 77,
151
152 /// The C convention as specified in the x86-64 supplement to the
153 /// System V ABI, used on most non-Windows systems.
154 X86_64_SysV = 78,
155
156 /// The C convention as implemented on Windows/x86-64 and
157 /// AArch64. This convention differs from the more common
158 /// \c X86_64_SysV convention in a number of ways, most notably in
159 /// that XMM registers used to pass arguments are shadowed by GPRs,
160 /// and vice versa.
161 /// On AArch64, this is identical to the normal C (AAPCS) calling
162 /// convention for normal functions, but floats are passed in integer
163 /// registers to variadic functions.
164 Win64 = 79,
165
166 /// MSVC calling convention that passes vectors and vector aggregates
167 /// in SSE registers.
168 X86_VectorCall = 80,
169
170 /// Calling convention used by HipHop Virtual Machine (HHVM) to
171 /// perform calls to and from translation cache, and for calling PHP
172 /// functions.
173 /// HHVM calling convention supports tail/sibling call elimination.
174 HHVM = 81,
175
176 /// HHVM calling convention for invoking C/C++ helpers.
177 HHVM_C = 82,
178
179 /// X86_INTR - x86 hardware interrupt context. Callee may take one or two
180 /// parameters, where the 1st represents a pointer to hardware context frame
181 /// and the 2nd represents hardware error code, the presence of the later
182 /// depends on the interrupt vector taken. Valid for both 32- and 64-bit
183 /// subtargets.
184 X86_INTR = 83,
185
186 /// Used for AVR interrupt routines.
187 AVR_INTR = 84,
188
189 /// Calling convention used for AVR signal routines.
190 AVR_SIGNAL = 85,
191
192 /// Calling convention used for special AVR rtlib functions
193 /// which have an "optimized" convention to preserve registers.
194 AVR_BUILTIN = 86,
195
196 /// Calling convention used for Mesa vertex shaders, or AMDPAL last shader
197 /// stage before rasterization (vertex shader if tessellation and geometry
198 /// are not in use, or otherwise copy shader if one is needed).
199 AMDGPU_VS = 87,
200
201 /// Calling convention used for Mesa/AMDPAL geometry shaders.
202 AMDGPU_GS = 88,
203
204 /// Calling convention used for Mesa/AMDPAL pixel shaders.
205 AMDGPU_PS = 89,
206
207 /// Calling convention used for Mesa/AMDPAL compute shaders.
208 AMDGPU_CS = 90,
209
210 /// Calling convention for AMDGPU code object kernels.
211 AMDGPU_KERNEL = 91,
212
213 /// Register calling convention used for parameters transfer optimization
214 X86_RegCall = 92,
215
216 /// Calling convention used for Mesa/AMDPAL hull shaders (= tessellation
217 /// control shaders).
218 AMDGPU_HS = 93,
219
220 /// Calling convention used for special MSP430 rtlib functions
221 /// which have an "optimized" convention using additional registers.
222 MSP430_BUILTIN = 94,
223
224 /// Calling convention used for AMDPAL vertex shader if tessellation is in
225 /// use.
226 AMDGPU_LS = 95,
227
228 /// Calling convention used for AMDPAL shader stage before geometry shader
229 /// if geometry is in use. So either the domain (= tessellation evaluation)
230 /// shader if tessellation is in use, or otherwise the vertex shader.
231 AMDGPU_ES = 96,
232
233 // Calling convention between AArch64 Advanced SIMD functions
234 AArch64_VectorCall = 97,
235
236 /// Calling convention between AArch64 SVE functions
237 AArch64_SVE_VectorCall = 98,
238
239 /// Calling convention for emscripten __invoke_* functions. The first
240 /// argument is required to be the function ptr being indirectly called.
241 /// The remainder matches the regular calling convention.
242 WASM_EmscriptenInvoke = 99,
243
244 /// Calling convention used for AMD graphics targets.
245 AMDGPU_Gfx = 100,
246
247 /// M68k_INTR - Calling convention used for M68k interrupt routines.
248 M68k_INTR = 101,
249
250 /// The highest possible calling convention ID. Must be some 2^k - 1.
251 MaxID = 1023
252 };
253
254} // end namespace CallingConv
255
256} // end namespace llvm
257
258#endif // LLVM_IR_CALLINGCONV_H
259