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 atttribute 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<"CC_Sparc64_Half">>,
129
130  // Otherwise, return values are passed exactly like arguments.
131  CCDelegateTo<CC_Sparc64>
132]>;
133
134// Callee-saved registers are handled by the register window mechanism.
135def CSR : CalleeSavedRegs<(add)> {
136  let OtherPreserved = (add (sequence "I%u", 0, 7),
137                            (sequence "L%u", 0, 7));
138}
139
140// Callee-saved registers for calls with ReturnsTwice attribute.
141def RTCSR : CalleeSavedRegs<(add)> {
142  let OtherPreserved = (add I6, I7);
143}
144