1//===-- SparcCallingConv.td - Calling Conventions Sparc ----*- 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// 9// This describes the calling conventions for the Sparc architectures. 10// 11//===----------------------------------------------------------------------===// 12 13//===----------------------------------------------------------------------===// 14// SPARC v8 32-bit. 15//===----------------------------------------------------------------------===// 16 17def CC_Sparc32 : CallingConv<[ 18 // Custom assign SRet to [sp+64]. 19 CCIfSRet<CCCustom<"CC_Sparc_Assign_SRet">>, 20 // i32 f32 arguments get passed in integer registers if there is space. 21 CCIfType<[i32, f32], CCAssignToReg<[I0, I1, I2, I3, I4, I5]>>, 22 // f64 arguments are split and passed through registers or through stack. 23 CCIfType<[f64], CCCustom<"CC_Sparc_Assign_Split_64">>, 24 // As are v2i32 arguments (this would be the default behavior for 25 // v2i32 if it wasn't allocated to the IntPair register-class) 26 CCIfType<[v2i32], CCCustom<"CC_Sparc_Assign_Split_64">>, 27 28 29 // Alternatively, they are assigned to the stack in 4-byte aligned units. 30 CCAssignToStack<4, 4> 31]>; 32 33def RetCC_Sparc32 : CallingConv<[ 34 CCIfType<[i32], CCAssignToReg<[I0, I1, I2, I3, I4, I5]>>, 35 CCIfType<[f32], CCAssignToReg<[F0, F1, F2, F3]>>, 36 CCIfType<[f64], CCAssignToReg<[D0, D1]>>, 37 CCIfType<[v2i32], CCCustom<"CC_Sparc_Assign_Ret_Split_64">> 38]>; 39 40 41//===----------------------------------------------------------------------===// 42// SPARC v9 64-bit. 43//===----------------------------------------------------------------------===// 44// 45// The 64-bit ABI conceptually assigns all function arguments to a parameter 46// array starting at [%fp+BIAS+128] in the callee's stack frame. All arguments 47// occupy a multiple of 8 bytes in the array. Integer arguments are extended to 48// 64 bits by the caller. Floats are right-aligned in their 8-byte slot, the 49// first 4 bytes in the slot are undefined. 50// 51// The integer registers %i0 to %i5 shadow the first 48 bytes of the parameter 52// array at fixed offsets. Integer arguments are promoted to registers when 53// possible. 54// 55// The floating point registers %f0 to %f31 shadow the first 128 bytes of the 56// parameter array at fixed offsets. Float and double parameters are promoted 57// to these registers when possible. 58// 59// Structs up to 16 bytes in size are passed by value. They are right-aligned 60// in one or two 8-byte slots in the parameter array. Struct members are 61// promoted to both floating point and integer registers when possible. A 62// struct containing two floats would thus be passed in %f0 and %f1, while two 63// float function arguments would occupy 8 bytes each, and be passed in %f1 and 64// %f3. 65// 66// When a struct { int, float } is passed by value, the int goes in the high 67// bits of an integer register while the float goes in a floating point 68// register. 69// 70// The difference is encoded in LLVM IR using the inreg attribute on function 71// arguments: 72// 73// C: void f(float, float); 74// IR: declare void f(float %f1, float %f3) 75// 76// C: void f(struct { float f0, f1; }); 77// IR: declare void f(float inreg %f0, float inreg %f1) 78// 79// C: void f(int, float); 80// IR: declare void f(int signext %i0, float %f3) 81// 82// C: void f(struct { int i0high; float f1; }); 83// IR: declare void f(i32 inreg %i0high, float inreg %f1) 84// 85// Two ints in a struct are simply coerced to i64: 86// 87// C: void f(struct { int i0high, i0low; }); 88// IR: declare void f(i64 %i0.coerced) 89// 90// The frontend and backend divide the task of producing ABI compliant code for 91// C functions. The C frontend will: 92// 93// - Annotate integer arguments with zeroext or signext attributes. 94// 95// - Split structs into one or two 64-bit sized chunks, or 32-bit chunks with 96// inreg attributes. 97// 98// - Pass structs larger than 16 bytes indirectly with an explicit pointer 99// argument. The byval attribute is not used. 100// 101// The backend will: 102// 103// - Assign all arguments to 64-bit aligned stack slots, 32-bits for inreg. 104// 105// - Promote to integer or floating point registers depending on type. 106// 107// Function return values are passed exactly like function arguments, except a 108// struct up to 32 bytes in size can be returned in registers. 109 110// Function arguments AND most return values. 111def CC_Sparc64 : CallingConv<[ 112 // The frontend uses the inreg flag to indicate i32 and float arguments from 113 // structs. These arguments are not promoted to 64 bits, but they can still 114 // be assigned to integer and float registers. 115 CCIfInReg<CCIfType<[i32, f32], CCCustom<"CC_Sparc64_Half">>>, 116 117 // All integers are promoted to i64 by the caller. 118 CCIfType<[i32], CCPromoteToType<i64>>, 119 120 // Custom assignment is required because stack space is reserved for all 121 // arguments whether they are passed in registers or not. 122 CCCustom<"CC_Sparc64_Full"> 123]>; 124 125def RetCC_Sparc64 : CallingConv<[ 126 // A single f32 return value always goes in %f0. The ABI doesn't specify what 127 // happens to multiple f32 return values outside a struct. 128 CCIfType<[f32], CCCustom<"RetCC_Sparc64_Half">>, 129 130 // Otherwise, return values are passed exactly like arguments, except that 131 // returns that are too big to fit into the registers is passed as an sret 132 // instead. 133 CCIfInReg<CCIfType<[i32, f32], CCCustom<"RetCC_Sparc64_Half">>>, 134 CCIfType<[i32], CCPromoteToType<i64>>, 135 CCCustom<"RetCC_Sparc64_Full"> 136]>; 137 138// Callee-saved registers are handled by the register window mechanism. 139def CSR : CalleeSavedRegs<(add)> { 140 let OtherPreserved = (add (sequence "I%u", 0, 7), 141 (sequence "L%u", 0, 7), O6); 142} 143 144// Callee-saved registers for calls with ReturnsTwice attribute. 145def RTCSR : CalleeSavedRegs<(add)> { 146 let OtherPreserved = (add I6, I7); 147} 148