1//=- SystemZCallingConv.td - Calling conventions for SystemZ -*- tablegen -*-=//
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// This describes the calling conventions for the SystemZ ABI.
9//===----------------------------------------------------------------------===//
10
11class CCIfExtend<CCAction A>
12  : CCIf<"ArgFlags.isSExt() || ArgFlags.isZExt()", A>;
13
14class CCIfSubtarget<string F, CCAction A>
15  : CCIf<!strconcat("static_cast<const SystemZSubtarget&>"
16                    "(State.getMachineFunction().getSubtarget()).", F),
17         A>;
18
19// Match if this specific argument is a fixed (i.e. named) argument.
20class CCIfFixed<CCAction A>
21    : CCIf<"static_cast<SystemZCCState *>(&State)->IsFixed(ValNo)", A>;
22
23// Match if this specific argument is not a fixed (i.e. vararg) argument.
24class CCIfNotFixed<CCAction A>
25    : CCIf<"!(static_cast<SystemZCCState *>(&State)->IsFixed(ValNo))", A>;
26
27// Match if this specific argument was widened from a short vector type.
28class CCIfShortVector<CCAction A>
29    : CCIf<"static_cast<SystemZCCState *>(&State)->IsShortVector(ValNo)", A>;
30
31
32//===----------------------------------------------------------------------===//
33// z/Linux return value calling convention
34//===----------------------------------------------------------------------===//
35def RetCC_SystemZ_ELF : CallingConv<[
36  // Promote i32 to i64 if it has an explicit extension type.
37  CCIfType<[i32], CCIfExtend<CCPromoteToType<i64>>>,
38
39  // A SwiftError is returned in R9.
40  CCIfSwiftError<CCIfType<[i64], CCAssignToReg<[R9D]>>>,
41
42  // ABI-compliant code returns 64-bit integers in R2.  Make the other
43  // call-clobbered argument registers available for code that doesn't
44  // care about the ABI.  (R6 is an argument register too, but is
45  // call-saved and therefore not suitable for return values.)
46  CCIfType<[i32], CCAssignToReg<[R2L, R3L, R4L, R5L]>>,
47  CCIfType<[i64], CCAssignToReg<[R2D, R3D, R4D, R5D]>>,
48
49  // ABI-complaint code returns float and double in F0.  Make the
50  // other floating-point argument registers available for code that
51  // doesn't care about the ABI.  All floating-point argument registers
52  // are call-clobbered, so we can use all of them here.
53  CCIfType<[f32], CCAssignToReg<[F0S, F2S, F4S, F6S]>>,
54  CCIfType<[f64], CCAssignToReg<[F0D, F2D, F4D, F6D]>>,
55
56  // Similarly for vectors, with V24 being the ABI-compliant choice.
57  // Sub-128 vectors are returned in the same way, but they're widened
58  // to one of these types during type legalization.
59  CCIfSubtarget<"hasVector()",
60    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
61             CCAssignToReg<[V24, V26, V28, V30, V25, V27, V29, V31]>>>
62]>;
63
64//===----------------------------------------------------------------------===//
65// z/Linux argument calling conventions for GHC
66//===----------------------------------------------------------------------===//
67def CC_SystemZ_GHC : CallingConv<[
68  // Pass in STG registers: Base, Sp, Hp, R1, R2, R3, R4, R5, R6, R7, R8, SpLim
69  CCIfType<[i64], CCAssignToReg<[R7D, R8D, R10D, R11D, R12D, R13D,
70                                 R6D, R2D, R3D, R4D, R5D, R9D]>>,
71
72  // Pass in STG registers: F1, ..., F6
73  CCIfType<[f32], CCAssignToReg<[F8S, F9S, F10S, F11S, F0S, F1S]>>,
74
75  // Pass in STG registers: D1, ..., D6
76  CCIfType<[f64], CCAssignToReg<[F12D, F13D, F14D, F15D, F2D, F3D]>>,
77
78  // Pass in STG registers: XMM1, ..., XMM6
79  CCIfSubtarget<"hasVector()",
80    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
81             CCIfFixed<CCAssignToReg<[V16, V17, V18, V19, V20, V21]>>>>,
82
83  // Fail otherwise
84  CCCustom<"CC_SystemZ_GHC_Error">
85]>;
86
87//===----------------------------------------------------------------------===//
88// z/Linux argument calling conventions
89//===----------------------------------------------------------------------===//
90def CC_SystemZ_ELF : CallingConv<[
91  CCIfCC<"CallingConv::GHC", CCDelegateTo<CC_SystemZ_GHC>>,
92
93  // Promote i32 to i64 if it has an explicit extension type.
94  // The convention is that true integer arguments that are smaller
95  // than 64 bits should be marked as extended, but structures that
96  // are smaller than 64 bits shouldn't.
97  CCIfType<[i32], CCIfExtend<CCPromoteToType<i64>>>,
98
99  // A SwiftSelf is passed in callee-saved R10.
100  CCIfSwiftSelf<CCIfType<[i64], CCAssignToReg<[R10D]>>>,
101
102  // A SwiftError is passed in callee-saved R9.
103  CCIfSwiftError<CCIfType<[i64], CCAssignToReg<[R9D]>>>,
104
105  // Force long double values to the stack and pass i64 pointers to them.
106  CCIfType<[f128], CCPassIndirect<i64>>,
107  // Same for i128 values.  These are already split into two i64 here,
108  // so we have to use a custom handler.
109  CCIfType<[i64], CCCustom<"CC_SystemZ_I128Indirect">>,
110
111  // The first 5 integer arguments are passed in R2-R6.  Note that R6
112  // is call-saved.
113  CCIfType<[i32], CCAssignToReg<[R2L, R3L, R4L, R5L, R6L]>>,
114  CCIfType<[i64], CCAssignToReg<[R2D, R3D, R4D, R5D, R6D]>>,
115
116  // The first 4 float and double arguments are passed in even registers F0-F6.
117  CCIfType<[f32], CCAssignToReg<[F0S, F2S, F4S, F6S]>>,
118  CCIfType<[f64], CCAssignToReg<[F0D, F2D, F4D, F6D]>>,
119
120  // The first 8 named vector arguments are passed in V24-V31.  Sub-128 vectors
121  // are passed in the same way, but they're widened to one of these types
122  // during type legalization.
123  CCIfSubtarget<"hasVector()",
124    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
125             CCIfFixed<CCAssignToReg<[V24, V26, V28, V30,
126                                      V25, V27, V29, V31]>>>>,
127
128  // However, sub-128 vectors which need to go on the stack occupy just a
129  // single 8-byte-aligned 8-byte stack slot.  Pass as i64.
130  CCIfSubtarget<"hasVector()",
131    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
132             CCIfShortVector<CCBitConvertToType<i64>>>>,
133
134  // Other vector arguments are passed in 8-byte-aligned 16-byte stack slots.
135  CCIfSubtarget<"hasVector()",
136    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
137             CCAssignToStack<16, 8>>>,
138
139  // Other arguments are passed in 8-byte-aligned 8-byte stack slots.
140  CCIfType<[i32, i64, f32, f64], CCAssignToStack<8, 8>>
141]>;
142
143//===----------------------------------------------------------------------===//
144// z/Linux callee-saved registers
145//===----------------------------------------------------------------------===//
146def CSR_SystemZ_ELF : CalleeSavedRegs<(add (sequence "R%dD", 6, 15),
147                                       (sequence "F%dD", 8, 15))>;
148
149// R9 is used to return SwiftError; remove it from CSR.
150def CSR_SystemZ_SwiftError : CalleeSavedRegs<(sub CSR_SystemZ_ELF, R9D)>;
151
152// "All registers" as used by the AnyReg calling convention.
153// Note that registers 0 and 1 are still defined as intra-call scratch
154// registers that may be clobbered e.g. by PLT stubs.
155def CSR_SystemZ_AllRegs : CalleeSavedRegs<(add (sequence "R%dD", 2, 15),
156                                               (sequence "F%dD", 0, 15))>;
157def CSR_SystemZ_AllRegs_Vector : CalleeSavedRegs<(add (sequence "R%dD", 2, 15),
158                                                      (sequence "V%d", 0, 31))>;
159
160def CSR_SystemZ_NoRegs : CalleeSavedRegs<(add)>;
161
162//===----------------------------------------------------------------------===//
163// z/OS XPLINK64 callee-saved registers
164//===----------------------------------------------------------------------===//
165def CSR_SystemZ_XPLINK64 : CalleeSavedRegs<(add (sequence "R%dD", 8, 15),
166                                                (sequence "F%dD", 15, 8))>;
167
168def CSR_SystemZ_XPLINK64_Vector : CalleeSavedRegs<(add CSR_SystemZ_XPLINK64,
169                                                   (sequence "V%d", 23, 16))>;
170
171//===----------------------------------------------------------------------===//
172// z/OS XPLINK64 return value calling convention
173//===----------------------------------------------------------------------===//
174def RetCC_SystemZ_XPLINK64 : CallingConv<[
175  // XPLINK64 ABI compliant code widens integral types smaller than i64
176  // to i64.
177  CCIfType<[i32], CCPromoteToType<i64>>,
178
179  // Structs of size 1-24 bytes are returned in R1D, R2D, and R3D.
180  CCIfType<[i64], CCIfInReg<CCAssignToReg<[R1D, R2D, R3D]>>>,
181  // An i64 is returned in R3D. R2D and R1D provided for ABI non-compliant
182  // code.
183  CCIfType<[i64], CCAssignToReg<[R3D, R2D, R1D]>>,
184
185  // ABI compliant code returns floating point values in FPR0, FPR2, FPR4
186  // and FPR6, using as many registers as required.
187  // All floating point return-value registers are call-clobbered.
188  CCIfType<[f32], CCAssignToReg<[F0S, F2S, F4S, F6S]>>,
189  CCIfType<[f64], CCAssignToReg<[F0D, F2D, F4D, F6D]>>,
190
191  // ABI compliant code returns f128 in F0D and F2D, hence F0Q.
192  // F4D and F6D, hence F4Q are used for complex long double types.
193  CCIfType<[f128], CCAssignToReg<[F0Q,F4Q]>>,
194
195  // ABI compliant code returns vectors in VR24 but other registers
196  // are provided for code that does not care about the ABI.
197  CCIfSubtarget<"hasVector()",
198    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
199             CCAssignToReg<[V24, V25, V26, V27, V28, V29, V30, V31]>>>
200]>;
201
202//===----------------------------------------------------------------------===//
203// z/OS XPLINK64 argument calling conventions
204//===----------------------------------------------------------------------===//
205// XPLink uses a logical argument list consisting of contiguous register-size
206// words (8 bytes in 64-Bit mode) where some arguments are passed in registers
207// and some in storage.
208// Even though 3 GPRs, 4 FPRs, and 8 VRs may be used,
209// space must be reserved for all the args on stack.
210// The first three register-sized words of the parameter area are passed in
211// GPRs 1-3. FP values and vector-type arguments are instead passed in FPRs
212// and VRs respectively, but if a FP value or vector argument occupies one of
213// the first three register-sized words of the parameter area, the corresponding
214// GPR's value is not used to pass arguments.
215//
216// The XPLINK64 Calling Convention is fully specified in Chapter 22 of the z/OS
217// Language Environment Vendor Interfaces. Appendix B of the same document contains
218// examples.
219
220def CC_SystemZ_XPLINK64 : CallingConv<[
221  // XPLINK64 ABI compliant code widens integral types smaller than i64
222  // to i64 before placing the parameters either on the stack or in registers.
223  CCIfType<[i32], CCIfExtend<CCPromoteToType<i64>>>,
224  // Promote f32 to f64 and bitcast to i64, if it needs to be passed in GPRs.
225  // Although we assign the f32 vararg to be bitcast, it will first be promoted
226  // to an f64 within convertValVTToLocVT().
227  CCIfType<[f32, f64], CCIfNotFixed<CCBitConvertToType<i64>>>,
228  // long double, can only be passed in GPR2 and GPR3, if available,
229  // hence R2Q
230  CCIfType<[f128], CCIfNotFixed<CCCustom<"CC_XPLINK64_Allocate128BitVararg">>>,
231  // Non fixed vector arguments are treated in the same way as long
232  // doubles.
233  CCIfSubtarget<"hasVector()",
234    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
235      CCIfNotFixed<CCCustom<"CC_XPLINK64_Allocate128BitVararg">>>>,
236
237  // A SwiftSelf is passed in callee-saved R10.
238  CCIfSwiftSelf<CCIfType<[i64], CCAssignToReg<[R10D]>>>,
239
240  // A SwiftError is passed in R0.
241  CCIfSwiftError<CCIfType<[i64], CCAssignToReg<[R0D]>>>,
242
243  // First i128 values. These are already split into two i64 here,
244  // so we have to use a custom handler and assign into registers, if possible
245  // We need to deal with this first
246  CCIfType<[i64], CCCustom<"CC_SystemZ_I128Indirect">>,
247  // The first 3 integer arguments are passed in registers R1D-R3D.
248  // The rest will be passed in the user area. The address offset of the user
249  // area can be found in register R4D.
250  CCIfType<[i64], CCAssignToRegAndStack<[R1D, R2D, R3D], 8, 8>>,
251
252  // The first 8 named vector arguments are passed in V24-V31. Sub-128 vectors
253  // are passed in the same way, but they're widened to one of these types
254  // during type legalization.
255  CCIfSubtarget<"hasVector()",
256    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
257      CCIfFixed<CCCustom<"CC_XPLINK64_Shadow_Reg">>>>,
258  CCIfSubtarget<"hasVector()",
259    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
260              CCIfFixed<CCAssignToRegAndStack<[V24, V25, V26, V27,
261                                               V28, V29, V30, V31], 16, 8>>>>,
262
263  // The first 4 named float and double arguments are passed in registers
264  // FPR0-FPR6. The rest will be passed in the user area.
265  CCIfType<[f32, f64], CCIfFixed<CCCustom<"CC_XPLINK64_Shadow_Reg">>>,
266  CCIfType<[f32], CCIfFixed<CCAssignToRegAndStack<[F0S, F2S, F4S, F6S], 4, 8>>>,
267  CCIfType<[f64], CCIfFixed<CCAssignToRegAndStack<[F0D, F2D, F4D, F6D], 8, 8>>>,
268
269  // The first 2 long double arguments are passed in register FPR0/FPR2
270  // and FPR4/FPR6. The rest will be passed in the user area.
271  CCIfType<[f128], CCIfFixed<CCCustom<"CC_XPLINK64_Shadow_Reg">>>,
272  CCIfType<[f128], CCIfFixed<CCAssignToRegAndStack<[F0Q, F4Q], 16, 8>>>,
273
274  // Other arguments are passed in 8-byte-aligned 8-byte stack slots.
275  CCIfType<[i32, i64, f32, f64], CCAssignToStack<8, 8>>,
276  // Other f128 arguments are passed in 8-byte-aligned 16-byte stack slots.
277  CCIfType<[f128], CCAssignToStack<16, 8>>,
278  // Vector arguments are passed in 8-byte-alinged 16-byte stack slots too.
279  CCIfSubtarget<"hasVector()",
280    CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
281             CCAssignToStack<16, 8>>>
282]>;
283
284//===----------------------------------------------------------------------===//
285// s390x return value calling convention
286//===----------------------------------------------------------------------===//
287
288def RetCC_SystemZ : CallingConv<[
289  // zOS XPLINK64
290  CCIfSubtarget<"isTargetXPLINK64()", CCDelegateTo<RetCC_SystemZ_XPLINK64>>,
291
292  // ELF Linux SystemZ
293  CCIfSubtarget<"isTargetELF()", CCDelegateTo<RetCC_SystemZ_ELF>>
294]>;
295
296
297//===----------------------------------------------------------------------===//
298// s390x argument calling conventions
299//===----------------------------------------------------------------------===//
300def CC_SystemZ : CallingConv<[
301  // zOS XPLINK64
302  CCIfSubtarget<"isTargetXPLINK64()", CCDelegateTo<CC_SystemZ_XPLINK64>>,
303
304  // ELF Linux SystemZ
305  CCIfSubtarget<"isTargetELF()", CCDelegateTo<CC_SystemZ_ELF>>
306]>;
307