llvm/test/CodeGen/SystemZ/call-zos-01.ll

   1 ; Test the passing of scalar values in GPRs, FPRs in 64-bit calls on z/OS.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-ibm-zos -mcpu=z10 | FileCheck %s
   4
   5 ; CHECK-LABEL: call_char:
   6 ; CHECK: lghi  1, 8
   7 define i8 @call_char(){
   8   %retval = call i8 (i8) @pass_char(i8 8)
   9   ret i8 %retval
  10 }
  11
  12 ; CHECK-LABEL: call_short:
  13 ; CHECK: lghi  1, 16
  14 define i16 @call_short() {
  15 entry:
  16   %retval = call i16 (i16) @pass_short(i16 16)
  17   ret i16 %retval
  18 }
  19
  20 ; CHECK-LABEL: call_int:
  21 ; CHECK: lghi  1, 32
  22 ; CHECK: lghi  2, 33
  23 define i32 @call_int() {
  24 entry:
  25   %retval = call i32 (i32, i32) @pass_int(i32 32, i32 33)
  26   ret i32 %retval
  27 }
  28
  29 ; CHECK-LABEL: call_long:
  30 ; CHECK: lghi  1, 64
  31 ; CHECK: lghi  2, 65
  32 ; CHECK: lghi  3, 66
  33 define i64 @call_long() {
  34 entry:
  35   %retval = call i64 (i64, i64, i64) @pass_long(i64 64, i64 65, i64 66)
  36   ret i64 %retval
  37 }
  38
  39 ; CHECK-LABEL: call_ptr:
  40 ; CHECK: lgr 1, 2
  41 define i32 @call_ptr(ptr %p1, ptr %p2) {
  42 entry:
  43   %retval = call i32 (ptr) @pass_ptr(ptr %p2)
  44   ret i32 %retval
  45 }
  46
  47 ; CHECK-LABEL: call_integrals:
  48 ; CHECK: lghi  1, 64
  49 ; CHECK: lghi  2, 32
  50 ; CHECK: lghi  3, 16
  51 define i64 @call_integrals() {
  52 entry:
  53   %retval = call i64 (i64, i32, i16, i64) @pass_integrals0(i64 64, i32 32, i16 16, i64 128)
  54   ret i64 %retval
  55 }
  56
  57 ; CHECK-LABEL: pass_char:
  58 ; CHECK: lgr 3, 1
  59 define signext i8 @pass_char(i8 signext %arg) {
  60 entry:
  61   ret i8 %arg
  62 }
  63
  64 ; CHECK-LABEL: pass_short:
  65 ; CHECK: lgr 3, 1
  66 define signext i16 @pass_short(i16 signext %arg) {
  67 entry:
  68   ret i16 %arg
  69 }
  70
  71 ; CHECK-LABEL: pass_int:
  72 ; CHECK: lgr 3, 2
  73 define signext i32 @pass_int(i32 signext %arg0, i32 signext %arg1) {
  74 entry:
  75   ret i32 %arg1
  76 }
  77
  78 ; CHECK-LABEL: pass_long:
  79 ; CHECK: agr 1, 2
  80 ; CHECK: agr 3, 1
  81 define signext i64 @pass_long(i64 signext %arg0, i64 signext %arg1, i64 signext %arg2) {
  82 entry:
  83   %N = add i64 %arg0, %arg1
  84   %M = add i64 %N, %arg2
  85   ret i64 %M
  86 }
  87
  88 ; CHECK-LABEL: pass_integrals0:
  89 ; CHECK: ag  2, 2200(4)
  90 ; CHECK-NEXT: lgr 3, 2
  91 define signext i64 @pass_integrals0(i64 signext %arg0, i32 signext %arg1, i16 signext %arg2, i64 signext %arg3) {
  92 entry:
  93   %N = sext i32 %arg1 to i64
  94   %M = add i64 %arg3, %N
  95   ret i64 %M
  96 }
  97
  98 ; CHECK-LABEL: call_float:
  99 ; CHECK: le 0, 0({{[0-9]}})
 100 define float @call_float() {
 101 entry:
 102   %ret = call float (float) @pass_float(float 0x400921FB60000000)
 103   ret float %ret
 104 }
 105
 106 ; CHECK-LABEL: call_double:
 107 ; CHECK: larl  [[GENREG:[0-9]+]], L#{{CPI[0-9]+_[0-9]+}}
 108 ; CHECK-NEXT: ld  0, 0([[GENREG]])
 109 define double @call_double() {
 110 entry:
 111   %ret = call double (double) @pass_double(double 3.141000e+00)
 112   ret double %ret
 113 }
 114
 115 ; CHECK-LABEL: call_longdouble:
 116 ; CHECK: larl  [[GENREG:[0-9]+]], L#{{CPI[0-9]+_[0-9]+}}
 117 ; CHECK-NEXT: ld  0, 0([[GENREG]])
 118 ; CHECK-NEXT: ld  2, 8([[GENREG]])
 119 define fp128 @call_longdouble() {
 120 entry:
 121   %ret = call fp128 (fp128) @pass_longdouble(fp128 0xLE0FC1518450562CD4000921FB5444261)
 122   ret fp128 %ret
 123 }
 124
 125 ; CHECK-LABEL: call_floats0
 126 ; CHECK: larl  [[GENREG:[0-9]+]], L#{{CPI[0-9]+_[0-9]+}}
 127 ; CHECK-NEXT: ld  1, 0([[GENREG]])
 128 ; CHECK-NEXT: ld  3, 8([[GENREG]])
 129 ; CHECK: lxr 5, 0
 130 ; CHECK: lxr 0, 1
 131 ; CHECK: lxr 4, 5
 132 define i64 @call_floats0(fp128 %arg0, double %arg1) {
 133 entry:
 134   %ret = call i64 (fp128, fp128, double) @pass_floats0(fp128 0xLE0FC1518450562CD4000921FB5444261, fp128 %arg0, double %arg1)
 135   ret i64 %ret
 136 }
 137
 138 ; CHECK-LABEL: call_floats1
 139 ; CHECK: lxr 1, 0
 140 ; CHECK: ldr 0, 4
 141 ; CHECK: lxr 4, 1
 142 define i64 @call_floats1(fp128 %arg0, double %arg1) {
 143 entry:
 144   %ret = call i64 (double, fp128) @pass_floats1(double %arg1, fp128 %arg0)
 145   ret i64 %ret
 146 }
 147
 148 ; CHECK-LABEL: pass_float:
 149 ; CHECK: larl  1, L#{{CPI[0-9]+_[0-9]+}}
 150 ; CHECK: aeb 0, 0(1)
 151 define float @pass_float(float %arg) {
 152 entry:
 153   %X = fadd float %arg, 0x400821FB60000000
 154   ret float %X
 155 }
 156
 157 ; CHECK-LABEL: pass_double:
 158 ; CHECK: larl  1, L#{{CPI[0-9]+_[0-9]+}}
 159 ; CHECK: adb 0, 0(1)
 160 define double @pass_double(double %arg) {
 161 entry:
 162   %X = fadd double %arg, 1.414213e+00
 163   ret double %X
 164 }
 165
 166 ; CHECK-LABEL: pass_longdouble
 167 ; CHECK: larl  1, L#{{CPI[0-9]+_[0-9]+}}
 168 ; CHECK: lxdb  1, 0(1)
 169 ; CHECK: axbr  0, 1
 170 define fp128 @pass_longdouble(fp128 %arg) {
 171 entry:
 172   %X = fadd fp128 %arg, 0xL10000000000000004000921FB53C8D4F
 173   ret fp128 %X
 174 }
 175
 176 ; CHECK-LABEL: pass_floats0
 177 ; CHECK: larl  1, L#{{CPI[0-9]+_[0-9]+}}
 178 ; CHECK: axbr  0, 4
 179 ; CHECK: axbr  1, 0
 180 ; CHECK: cxbr  1, 5
 181 define i64 @pass_floats0(fp128 %arg0, fp128 %arg1, double %arg2) {
 182   %X = fadd fp128 %arg0, %arg1
 183   %arg2_ext = fpext double %arg2 to fp128
 184   %Y = fadd fp128 %X, %arg2_ext
 185   %ret_bool = fcmp ueq fp128 %Y, 0xLE0FC1518450562CD4000921FB5444261
 186   %ret = sext i1 %ret_bool to i64
 187   ret i64 %ret
 188 }
 189
 190 declare i64 @pass_floats1(double %arg0, fp128 %arg1)
 191 declare i32 @pass_ptr(ptr %arg)