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