contrib/llvm/lib/Target/Sparc/SparcCallingConv.td

   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
  17 def 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
  33 def 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.
 111 def 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
 125 def 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.
 135 def 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.
 141 def RTCSR : CalleeSavedRegs<(add)> {
 142   let OtherPreserved = (add I6, I7);
 143 }