llvm/test/CodeGen/SPIRV/llvm-intrinsics/fp-intrinsics.ll

   1 ; RUN: llc -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
   2
   3 ; CHECK: %[[#extinst_id:]] = OpExtInstImport "OpenCL.std"
   4
   5 ; CHECK: %[[#var0:]] = OpTypeFloat 16
   6 ; CHECK: %[[#var1:]] = OpTypeFloat 32
   7 ; CHECK: %[[#var2:]] = OpTypeFloat 64
   8 ; CHECK: %[[#var3:]] = OpTypeVector %[[#var1]] 4
   9
  10 ; CHECK: OpFunction
  11 ; CHECK: %[[#]] = OpExtInst %[[#var0]] %[[#extinst_id]] fabs
  12 ; CHECK: OpFunctionEnd
  13
  14 define spir_func half @TestFabs16(half %x) local_unnamed_addr {
  15 entry:
  16   %t = tail call half @llvm.fabs.f16(half %x)
  17   ret half %t
  18 }
  19
  20 ; CHECK: OpFunction
  21 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] fabs
  22 ; CHECK: OpFunctionEnd
  23
  24 define spir_func float @TestFabs32(float %x) local_unnamed_addr {
  25 entry:
  26   %t = tail call float @llvm.fabs.f32(float %x)
  27   ret float %t
  28 }
  29
  30 ; CHECK: OpFunction
  31 ; CHECK: %[[#]] = OpExtInst %[[#var2]] %[[#extinst_id]] fabs
  32 ; CHECK: OpFunctionEnd
  33
  34 define spir_func double @TestFabs64(double %x) local_unnamed_addr {
  35 entry:
  36   %t = tail call double @llvm.fabs.f64(double %x)
  37   ret double %t
  38 }
  39
  40 ; CHECK: OpFunction
  41 ; CHECK: %[[#]] = OpExtInst %[[#var3]] %[[#extinst_id]] fabs
  42 ; CHECK: OpFunctionEnd
  43
  44 define spir_func <4 x float> @TestFabsVec(<4 x float> %x) local_unnamed_addr {
  45 entry:
  46   %t = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %x)
  47   ret <4 x float> %t
  48 }
  49
  50 declare half @llvm.fabs.f16(half)
  51 declare float @llvm.fabs.f32(float)
  52 declare double @llvm.fabs.f64(double)
  53 declare <4 x float> @llvm.fabs.v4f32(<4 x float>)
  54
  55 ;; We checked several types with fabs, but the type check works the same for
  56 ;; all intrinsics being translated, so for the rest we'll just test one type.
  57
  58 ; CHECK: OpFunction
  59 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] ceil
  60 ; CHECK: OpFunctionEnd
  61
  62 define spir_func float @TestCeil(float %x) local_unnamed_addr {
  63 entry:
  64   %t = tail call float @llvm.ceil.f32(float %x)
  65   ret float %t
  66 }
  67
  68 declare float @llvm.ceil.f32(float)
  69
  70 ; CHECK: OpFunction
  71 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
  72 ; CHECK: %[[#n:]] = OpFunctionParameter %[[#]]
  73 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] pown %[[#x]] %[[#n]]
  74 ; CHECK: OpFunctionEnd
  75
  76 define spir_func float @TestPowi(float %x, i32 %n) local_unnamed_addr {
  77 entry:
  78   %t = tail call float @llvm.powi.f32(float %x, i32 %n)
  79   ret float %t
  80 }
  81
  82 declare float @llvm.powi.f32(float, i32)
  83
  84 ; CHECK: OpFunction
  85 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] sin
  86 ; CHECK: OpFunctionEnd
  87
  88 define spir_func float @TestSin(float %x) local_unnamed_addr {
  89 entry:
  90   %t = tail call float @llvm.sin.f32(float %x)
  91   ret float %t
  92 }
  93
  94 declare float @llvm.sin.f32(float)
  95
  96 ; CHECK: OpFunction
  97 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] cos
  98 ; CHECK: OpFunctionEnd
  99
 100 define spir_func float @TestCos(float %x) local_unnamed_addr {
 101 entry:
 102   %t = tail call float @llvm.cos.f32(float %x)
 103   ret float %t
 104 }
 105
 106 declare float @llvm.cos.f32(float)
 107
 108 ; CHECK: OpFunction
 109 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
 110 ; CHECK: %[[#y:]] = OpFunctionParameter %[[#]]
 111 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] pow %[[#x]] %[[#y]]
 112 ; CHECK: OpFunctionEnd
 113
 114 define spir_func float @TestPow(float %x, float %y) local_unnamed_addr {
 115 entry:
 116   %t = tail call float @llvm.pow.f32(float %x, float %y)
 117   ret float %t
 118 }
 119
 120 declare float @llvm.pow.f32(float, float)
 121
 122 ; CHECK: OpFunction
 123 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] exp
 124 ; CHECK: OpFunctionEnd
 125
 126 define spir_func float @TestExp(float %x) local_unnamed_addr {
 127 entry:
 128   %t = tail call float @llvm.exp.f32(float %x)
 129   ret float %t
 130 }
 131
 132 declare float @llvm.exp.f32(float)
 133
 134 ; CHECK: OpFunction
 135 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] exp2
 136 ; CHECK: OpFunctionEnd
 137
 138 define spir_func float @TestExp2(float %x) local_unnamed_addr {
 139 entry:
 140   %t = tail call float @llvm.exp2.f32(float %x)
 141   ret float %t
 142 }
 143
 144 declare float @llvm.exp2.f32(float)
 145
 146 ; CHECK: OpFunction
 147 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] log
 148 ; CHECK: OpFunctionEnd
 149
 150 define spir_func float @TestLog(float %x) local_unnamed_addr {
 151 entry:
 152   %t = tail call float @llvm.log.f32(float %x)
 153   ret float %t
 154 }
 155
 156 declare float @llvm.log.f32(float)
 157
 158 ; CHECK: OpFunction
 159 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] log10
 160 ; CHECK: OpFunctionEnd
 161
 162 define spir_func float @TestLog10(float %x) local_unnamed_addr {
 163 entry:
 164   %t = tail call float @llvm.log10.f32(float %x)
 165   ret float %t
 166 }
 167
 168 declare float @llvm.log10.f32(float)
 169
 170 ; CHECK: OpFunction
 171 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] log2
 172 ; CHECK: OpFunctionEnd
 173
 174 define spir_func float @TestLog2(float %x) local_unnamed_addr {
 175 entry:
 176   %t = tail call float @llvm.log2.f32(float %x)
 177   ret float %t
 178 }
 179
 180 declare float @llvm.log2.f32(float)
 181
 182 ; CHECK: OpFunction
 183 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
 184 ; CHECK: %[[#y:]] = OpFunctionParameter %[[#]]
 185 ; CHECK: %[[#res:]] = OpExtInst %[[#]] %[[#]] fmin %[[#x]] %[[#y]]
 186 ; CHECK: OpReturnValue %[[#res]]
 187
 188 define spir_func float @TestMinNum(float %x, float %y) {
 189 entry:
 190   %t = call float @llvm.minnum.f32(float %x, float %y)
 191   ret float %t
 192 }
 193
 194 declare float @llvm.minnum.f32(float, float)
 195
 196 ; CHECK: OpFunction
 197 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
 198 ; CHECK: %[[#y:]] = OpFunctionParameter %[[#]]
 199 ; CHECK: %[[#res:]] = OpExtInst %[[#]] %[[#]] fmax %[[#x]] %[[#y]]
 200 ; CHECK: OpReturnValue %[[#res]]
 201
 202 define spir_func float @TestMaxNum(float %x, float %y) {
 203 entry:
 204   %t = call float @llvm.maxnum.f32(float %x, float %y)
 205   ret float %t
 206 }
 207
 208 declare float @llvm.maxnum.f32(float, float)
 209
 210 ; CHECK: OpFunction
 211 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
 212 ; CHECK: %[[#y:]] = OpFunctionParameter %[[#]]
 213 ; CHECK: %[[#res:]] = OpExtInst %[[#]] %[[#]] fmin %[[#x]] %[[#y]]
 214 ; CHECK: OpReturnValue %[[#res]]
 215
 216 define spir_func float @TestMinimum(float %x, float %y) {
 217 entry:
 218   %t = call float @llvm.minimum.f32(float %x, float %y)
 219   ret float %t
 220 }
 221
 222 declare float @llvm.minimum.f32(float, float)
 223
 224 ; CHECK: OpFunction
 225 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
 226 ; CHECK: %[[#y:]] = OpFunctionParameter %[[#]]
 227 ; CHECK: %[[#res:]] = OpExtInst %[[#]] %[[#]] fmax %[[#x]] %[[#y]]
 228 ; CHECK: OpReturnValue %[[#res]]
 229
 230 define spir_func float @TestMaximum(float %x, float %y) {
 231 entry:
 232   %t = call float @llvm.maximum.f32(float %x, float %y)
 233   ret float %t
 234 }
 235
 236 declare float @llvm.maximum.f32(float, float)
 237
 238 ; CHECK: OpFunction
 239 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
 240 ; CHECK: %[[#y:]] = OpFunctionParameter %[[#]]
 241 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] copysign %[[#x]] %[[#y]]
 242 ; CHECK: OpFunctionEnd
 243
 244 define spir_func float @TestCopysign(float %x, float %y) local_unnamed_addr {
 245 entry:
 246   %t = tail call float @llvm.copysign.f32(float %x, float %y)
 247   ret float %t
 248 }
 249
 250 declare float @llvm.copysign.f32(float, float)
 251
 252 ; CHECK: OpFunction
 253 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] floor
 254 ; CHECK: OpFunctionEnd
 255
 256 define spir_func float @TestFloor(float %x) local_unnamed_addr {
 257 entry:
 258   %t = tail call float @llvm.floor.f32(float %x)
 259   ret float %t
 260 }
 261
 262 declare float @llvm.floor.f32(float)
 263
 264 ; CHECK: OpFunction
 265 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] trunc
 266 ; CHECK: OpFunctionEnd
 267
 268 define spir_func float @TestTrunc(float %x) local_unnamed_addr {
 269 entry:
 270   %t = tail call float @llvm.trunc.f32(float %x)
 271   ret float %t
 272 }
 273
 274 declare float @llvm.trunc.f32(float)
 275
 276 ; CHECK: OpFunction
 277 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] rint
 278 ; CHECK: OpFunctionEnd
 279
 280 define spir_func float @TestRint(float %x) local_unnamed_addr {
 281 entry:
 282   %t = tail call float @llvm.rint.f32(float %x)
 283   ret float %t
 284 }
 285
 286 declare float @llvm.rint.f32(float)
 287
 288 ;; It is intentional that nearbyint translates to rint.
 289 ; CHECK: OpFunction
 290 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] rint
 291 ; CHECK: OpFunctionEnd
 292
 293 define spir_func float @TestNearbyint(float %x) local_unnamed_addr {
 294 entry:
 295   %t = tail call float @llvm.nearbyint.f32(float %x)
 296   ret float %t
 297 }
 298
 299 declare float @llvm.nearbyint.f32(float)
 300
 301 ; CHECK: OpFunction
 302 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] round
 303 ; CHECK: OpFunctionEnd
 304
 305 define spir_func float @TestRound(float %x) local_unnamed_addr {
 306 entry:
 307   %t = tail call float @llvm.round.f32(float %x)
 308   ret float %t
 309 }
 310
 311 declare float @llvm.round.f32(float)
 312
 313 ;; It is intentional that roundeven translates to rint.
 314 ; CHECK: OpFunction
 315 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] rint
 316 ; CHECK: OpFunctionEnd
 317
 318 define spir_func float @TestRoundEven(float %x) local_unnamed_addr {
 319 entry:
 320   %t = tail call float @llvm.roundeven.f32(float %x)
 321   ret float %t
 322 }
 323
 324 declare float @llvm.roundeven.f32(float)
 325
 326 ; CHECK: OpFunction
 327 ; CHECK: %[[#x:]] = OpFunctionParameter %[[#]]
 328 ; CHECK: %[[#y:]] = OpFunctionParameter %[[#]]
 329 ; CHECK: %[[#z:]] = OpFunctionParameter %[[#]]
 330 ; CHECK: %[[#]] = OpExtInst %[[#var1]] %[[#extinst_id]] fma %[[#x]] %[[#y]] %[[#z]]
 331 ; CHECK: OpFunctionEnd
 332
 333 define spir_func float @TestFma(float %x, float %y, float %z) {
 334 entry:
 335   %t = tail call float @llvm.fma.f32(float %x, float %y, float %z)
 336   ret float %t
 337 }
 338
 339 declare float @llvm.fma.f32(float, float, float)