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 | |
16 | namespace llvm { |
17 | |
18 | /// CallingConv Namespace - This namespace contains an enum with a value for |
19 | /// the well-known calling conventions. |
20 | /// |
21 | namespace 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 | |