1//=- SystemZCallingConv.td - Calling conventions for SystemZ -*- tablegen -*-=// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// This describes the calling conventions for the SystemZ ABI. 10//===----------------------------------------------------------------------===// 11 12class CCIfExtend<CCAction A> 13 : CCIf<"ArgFlags.isSExt() || ArgFlags.isZExt()", A>; 14 15class CCIfSubtarget<string F, CCAction A> 16 : CCIf<!strconcat("static_cast<const SystemZSubtarget&>" 17 "(State.getMachineFunction().getSubtarget()).", F), 18 A>; 19 20// Match if this specific argument is a fixed (i.e. named) argument. 21class CCIfFixed<CCAction A> 22 : CCIf<"static_cast<SystemZCCState *>(&State)->IsFixed(ValNo)", A>; 23 24// Match if this specific argument was widened from a short vector type. 25class CCIfShortVector<CCAction A> 26 : CCIf<"static_cast<SystemZCCState *>(&State)->IsShortVector(ValNo)", A>; 27 28 29//===----------------------------------------------------------------------===// 30// z/Linux return value calling convention 31//===----------------------------------------------------------------------===// 32def RetCC_SystemZ : CallingConv<[ 33 // Promote i32 to i64 if it has an explicit extension type. 34 CCIfType<[i32], CCIfExtend<CCPromoteToType<i64>>>, 35 36 // A SwiftError is returned in R9. 37 CCIfSwiftError<CCIfType<[i64], CCAssignToReg<[R9D]>>>, 38 39 // ABI-compliant code returns 64-bit integers in R2. Make the other 40 // call-clobbered argument registers available for code that doesn't 41 // care about the ABI. (R6 is an argument register too, but is 42 // call-saved and therefore not suitable for return values.) 43 CCIfType<[i32], CCAssignToReg<[R2L, R3L, R4L, R5L]>>, 44 CCIfType<[i64], CCAssignToReg<[R2D, R3D, R4D, R5D]>>, 45 46 // ABI-complaint code returns float and double in F0. Make the 47 // other floating-point argument registers available for code that 48 // doesn't care about the ABI. All floating-point argument registers 49 // are call-clobbered, so we can use all of them here. 50 CCIfType<[f32], CCAssignToReg<[F0S, F2S, F4S, F6S]>>, 51 CCIfType<[f64], CCAssignToReg<[F0D, F2D, F4D, F6D]>>, 52 53 // Similarly for vectors, with V24 being the ABI-compliant choice. 54 // Sub-128 vectors are returned in the same way, but they're widened 55 // to one of these types during type legalization. 56 CCIfSubtarget<"hasVector()", 57 CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], 58 CCAssignToReg<[V24, V26, V28, V30, V25, V27, V29, V31]>>> 59]>; 60 61//===----------------------------------------------------------------------===// 62// z/Linux argument calling conventions 63//===----------------------------------------------------------------------===// 64def CC_SystemZ : CallingConv<[ 65 // Promote i32 to i64 if it has an explicit extension type. 66 // The convention is that true integer arguments that are smaller 67 // than 64 bits should be marked as extended, but structures that 68 // are smaller than 64 bits shouldn't. 69 CCIfType<[i32], CCIfExtend<CCPromoteToType<i64>>>, 70 71 // A SwiftSelf is passed in callee-saved R10. 72 CCIfSwiftSelf<CCIfType<[i64], CCAssignToReg<[R10D]>>>, 73 74 // A SwiftError is passed in callee-saved R9. 75 CCIfSwiftError<CCIfType<[i64], CCAssignToReg<[R9D]>>>, 76 77 // Force long double values to the stack and pass i64 pointers to them. 78 CCIfType<[f128], CCPassIndirect<i64>>, 79 // Same for i128 values. These are already split into two i64 here, 80 // so we have to use a custom handler. 81 CCIfType<[i64], CCCustom<"CC_SystemZ_I128Indirect">>, 82 83 // The first 5 integer arguments are passed in R2-R6. Note that R6 84 // is call-saved. 85 CCIfType<[i32], CCAssignToReg<[R2L, R3L, R4L, R5L, R6L]>>, 86 CCIfType<[i64], CCAssignToReg<[R2D, R3D, R4D, R5D, R6D]>>, 87 88 // The first 4 float and double arguments are passed in even registers F0-F6. 89 CCIfType<[f32], CCAssignToReg<[F0S, F2S, F4S, F6S]>>, 90 CCIfType<[f64], CCAssignToReg<[F0D, F2D, F4D, F6D]>>, 91 92 // The first 8 named vector arguments are passed in V24-V31. Sub-128 vectors 93 // are passed in the same way, but they're widened to one of these types 94 // during type legalization. 95 CCIfSubtarget<"hasVector()", 96 CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], 97 CCIfFixed<CCAssignToReg<[V24, V26, V28, V30, 98 V25, V27, V29, V31]>>>>, 99 100 // However, sub-128 vectors which need to go on the stack occupy just a 101 // single 8-byte-aligned 8-byte stack slot. Pass as i64. 102 CCIfSubtarget<"hasVector()", 103 CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], 104 CCIfShortVector<CCBitConvertToType<i64>>>>, 105 106 // Other vector arguments are passed in 8-byte-aligned 16-byte stack slots. 107 CCIfSubtarget<"hasVector()", 108 CCIfType<[v16i8, v8i16, v4i32, v2i64, v4f32, v2f64], 109 CCAssignToStack<16, 8>>>, 110 111 // Other arguments are passed in 8-byte-aligned 8-byte stack slots. 112 CCIfType<[i32, i64, f32, f64], CCAssignToStack<8, 8>> 113]>; 114 115//===----------------------------------------------------------------------===// 116// z/Linux callee-saved registers 117//===----------------------------------------------------------------------===// 118def CSR_SystemZ : CalleeSavedRegs<(add (sequence "R%dD", 6, 15), 119 (sequence "F%dD", 8, 15))>; 120 121// R9 is used to return SwiftError; remove it from CSR. 122def CSR_SystemZ_SwiftError : CalleeSavedRegs<(sub CSR_SystemZ, R9D)>; 123 124// "All registers" as used by the AnyReg calling convention. 125// Note that registers 0 and 1 are still defined as intra-call scratch 126// registers that may be clobbered e.g. by PLT stubs. 127def CSR_SystemZ_AllRegs : CalleeSavedRegs<(add (sequence "R%dD", 2, 15), 128 (sequence "F%dD", 0, 15))>; 129def CSR_SystemZ_AllRegs_Vector : CalleeSavedRegs<(add (sequence "R%dD", 2, 15), 130 (sequence "V%d", 0, 31))>; 131 132