mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir

   1 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
   2
   3 //===----------------------------------------------------------------------===//
   4 // spirv.CL.exp
   5 //===----------------------------------------------------------------------===//
   6
   7 func.func @exp(%arg0 : f32) -> () {
   8   // CHECK: spirv.CL.exp {{%.*}} : f32
   9   %2 = spirv.CL.exp %arg0 : f32
  10   return
  11 }
  12
  13 func.func @expvec(%arg0 : vector<3xf16>) -> () {
  14   // CHECK: spirv.CL.exp {{%.*}} : vector<3xf16>
  15   %2 = spirv.CL.exp %arg0 : vector<3xf16>
  16   return
  17 }
  18
  19 // -----
  20
  21 func.func @exp(%arg0 : i32) -> () {
  22   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
  23   %2 = spirv.CL.exp %arg0 : i32
  24   return
  25 }
  26
  27 // -----
  28
  29 func.func @exp(%arg0 : vector<5xf32>) -> () {
  30   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}}
  31   %2 = spirv.CL.exp %arg0 : vector<5xf32>
  32   return
  33 }
  34
  35 // -----
  36
  37 func.func @exp(%arg0 : f32, %arg1 : f32) -> () {
  38   // expected-error @+1 {{expected ':'}}
  39   %2 = spirv.CL.exp %arg0, %arg1 : i32
  40   return
  41 }
  42
  43 // -----
  44
  45 func.func @exp(%arg0 : i32) -> () {
  46   // expected-error @+1 {{expected non-function type}}
  47   %2 = spirv.CL.exp %arg0 :
  48   return
  49 }
  50
  51 // -----
  52
  53 //===----------------------------------------------------------------------===//
  54 // spirv.CL.fabs
  55 //===----------------------------------------------------------------------===//
  56
  57 func.func @fabs(%arg0 : f32) -> () {
  58   // CHECK: spirv.CL.fabs {{%.*}} : f32
  59   %2 = spirv.CL.fabs %arg0 : f32
  60   return
  61 }
  62
  63 func.func @fabsvec(%arg0 : vector<3xf16>) -> () {
  64   // CHECK: spirv.CL.fabs {{%.*}} : vector<3xf16>
  65   %2 = spirv.CL.fabs %arg0 : vector<3xf16>
  66   return
  67 }
  68
  69 func.func @fabsf64(%arg0 : f64) -> () {
  70   // CHECK: spirv.CL.fabs {{%.*}} : f64
  71   %2 = spirv.CL.fabs %arg0 : f64
  72   return
  73 }
  74
  75 // -----
  76
  77 func.func @fabs(%arg0 : i32) -> () {
  78   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
  79   %2 = spirv.CL.fabs %arg0 : i32
  80   return
  81 }
  82
  83 // -----
  84
  85 func.func @fabs(%arg0 : vector<5xf32>) -> () {
  86   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}}
  87   %2 = spirv.CL.fabs %arg0 : vector<5xf32>
  88   return
  89 }
  90
  91 // -----
  92
  93 func.func @fabs(%arg0 : f32, %arg1 : f32) -> () {
  94   // expected-error @+1 {{expected ':'}}
  95   %2 = spirv.CL.fabs %arg0, %arg1 : i32
  96   return
  97 }
  98
  99 // -----
 100
 101 func.func @fabs(%arg0 : i32) -> () {
 102   // expected-error @+1 {{expected non-function type}}
 103   %2 = spirv.CL.fabs %arg0 :
 104   return
 105 }
 106
 107 // -----
 108
 109 //===----------------------------------------------------------------------===//
 110 // spirv.CL.s_abs
 111 //===----------------------------------------------------------------------===//
 112
 113 func.func @sabs(%arg0 : i32) -> () {
 114   // CHECK: spirv.CL.s_abs {{%.*}} : i32
 115   %2 = spirv.CL.s_abs %arg0 : i32
 116   return
 117 }
 118
 119 func.func @sabsvec(%arg0 : vector<3xi16>) -> () {
 120   // CHECK: spirv.CL.s_abs {{%.*}} : vector<3xi16>
 121   %2 = spirv.CL.s_abs %arg0 : vector<3xi16>
 122   return
 123 }
 124
 125 func.func @sabsi64(%arg0 : i64) -> () {
 126   // CHECK: spirv.CL.s_abs {{%.*}} : i64
 127   %2 = spirv.CL.s_abs %arg0 : i64
 128   return
 129 }
 130
 131 func.func @sabsi8(%arg0 : i8) -> () {
 132   // CHECK: spirv.CL.s_abs {{%.*}} : i8
 133   %2 = spirv.CL.s_abs %arg0 : i8
 134   return
 135 }
 136
 137 // -----
 138
 139 func.func @sabs(%arg0 : f32) -> () {
 140   // expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values}}
 141   %2 = spirv.CL.s_abs %arg0 : f32
 142   return
 143 }
 144
 145 // -----
 146
 147 func.func @sabs(%arg0 : vector<5xi32>) -> () {
 148   // expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}}
 149   %2 = spirv.CL.s_abs %arg0 : vector<5xi32>
 150   return
 151 }
 152
 153 // -----
 154
 155 func.func @sabs(%arg0 : i32, %arg1 : i32) -> () {
 156   // expected-error @+1 {{expected ':'}}
 157   %2 = spirv.CL.s_abs %arg0, %arg1 : i32
 158   return
 159 }
 160
 161 // -----
 162
 163 func.func @sabs(%arg0 : i32) -> () {
 164   // expected-error @+1 {{expected non-function type}}
 165   %2 = spirv.CL.s_abs %arg0 :
 166   return
 167 }
 168
 169 // -----
 170
 171 //===----------------------------------------------------------------------===//
 172 // spirv.CL.fma
 173 //===----------------------------------------------------------------------===//
 174
 175 func.func @fma(%a : f32, %b : f32, %c : f32) -> () {
 176   // CHECK: spirv.CL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
 177   %2 = spirv.CL.fma %a, %b, %c : f32
 178   return
 179 }
 180
 181 // -----
 182
 183 func.func @fma(%a : vector<3xf32>, %b : vector<3xf32>, %c : vector<3xf32>) -> () {
 184   // CHECK: spirv.CL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
 185   %2 = spirv.CL.fma %a, %b, %c : vector<3xf32>
 186   return
 187 }
 188
 189 // -----
 190
 191 //===----------------------------------------------------------------------===//
 192 // spirv.CL.mix
 193 //===----------------------------------------------------------------------===//
 194
 195 func.func @mix(%a : f32, %b : f32, %c : f32) -> () {
 196   // CHECK: spirv.CL.mix {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
 197   %2 = spirv.CL.mix %a, %b, %c : f32
 198   return
 199 }
 200
 201 // -----
 202
 203 func.func @mix(%a : vector<3xf32>, %b : vector<3xf32>, %c : vector<3xf32>) -> () {
 204   // CHECK: spirv.CL.mix {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
 205   %2 = spirv.CL.mix %a, %b, %c : vector<3xf32>
 206   return
 207 }
 208
 209 // -----
 210
 211 //===----------------------------------------------------------------------===//
 212 // spirv.CL.{F|S|U}{Max|Min}
 213 //===----------------------------------------------------------------------===//
 214
 215 func.func @fmaxmin(%arg0 : f32, %arg1 : f32) {
 216   // CHECK: spirv.CL.fmax {{%.*}}, {{%.*}} : f32
 217   %1 = spirv.CL.fmax %arg0, %arg1 : f32
 218   // CHECK: spirv.CL.fmin {{%.*}}, {{%.*}} : f32
 219   %2 = spirv.CL.fmin %arg0, %arg1 : f32
 220   return
 221 }
 222
 223 func.func @fmaxminvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) {
 224   // CHECK: spirv.CL.fmax {{%.*}}, {{%.*}} : vector<3xf16>
 225   %1 = spirv.CL.fmax %arg0, %arg1 : vector<3xf16>
 226   // CHECK: spirv.CL.fmin {{%.*}}, {{%.*}} : vector<3xf16>
 227   %2 = spirv.CL.fmin %arg0, %arg1 : vector<3xf16>
 228   return
 229 }
 230
 231 func.func @fmaxminf64(%arg0 : f64, %arg1 : f64) {
 232   // CHECK: spirv.CL.fmax {{%.*}}, {{%.*}} : f64
 233   %1 = spirv.CL.fmax %arg0, %arg1 : f64
 234   // CHECK: spirv.CL.fmin {{%.*}}, {{%.*}} : f64
 235   %2 = spirv.CL.fmin %arg0, %arg1 : f64
 236   return
 237 }
 238
 239 func.func @iminmax(%arg0: i32, %arg1: i32) {
 240   // CHECK: spirv.CL.s_max {{%.*}}, {{%.*}} : i32
 241   %1 = spirv.CL.s_max %arg0, %arg1 : i32
 242   // CHECK: spirv.CL.u_max {{%.*}}, {{%.*}} : i32
 243   %2 = spirv.CL.u_max %arg0, %arg1 : i32
 244   // CHECK: spirv.CL.s_min {{%.*}}, {{%.*}} : i32
 245   %3 = spirv.CL.s_min %arg0, %arg1 : i32
 246   // CHECK: spirv.CL.u_min {{%.*}}, {{%.*}} : i32
 247   %4 = spirv.CL.u_min %arg0, %arg1 : i32
 248   return
 249 }
 250
 251 // -----
 252
 253 //===----------------------------------------------------------------------===//
 254 // spirv.CL.rint
 255 //===----------------------------------------------------------------------===//
 256
 257 // CHECK-LABEL: func.func @rint(
 258 func.func @rint(%arg0 : f32) -> () {
 259   // CHECK: spirv.CL.rint {{%.*}} : f32
 260   %0 = spirv.CL.rint %arg0 : f32
 261   return
 262 }
 263
 264 // CHECK-LABEL: func.func @rintvec(
 265 func.func @rintvec(%arg0 : vector<3xf16>) -> () {
 266   // CHECK: spirv.CL.rint {{%.*}} : vector<3xf16>
 267   %0 = spirv.CL.rint %arg0 : vector<3xf16>
 268   return
 269 }
 270
 271 // -----
 272
 273 //===----------------------------------------------------------------------===//
 274 // spirv.CL.printf
 275 //===----------------------------------------------------------------------===//
 276 // CHECK-LABEL: func.func @printf(
 277 func.func @printf(%fmt : !spirv.ptr<i8, UniformConstant>, %arg1 : i32, %arg2 : i32) -> i32 {
 278   // CHECK: spirv.CL.printf {{%.*}} {{%.*}}, {{%.*}} : !spirv.ptr<i8, UniformConstant>, i32, i32 -> i32
 279   %0 = spirv.CL.printf %fmt %arg1, %arg2 : !spirv.ptr<i8, UniformConstant>, i32, i32 -> i32
 280   return %0 : i32
 281 }
 282
 283 // -----
 284
 285 func.func @tan(%arg0 : f32) -> () {
 286   // CHECK: spirv.CL.tan {{%.*}} : f32
 287   %2 = spirv.CL.tan %arg0 : f32
 288   return
 289 }
 290
 291 // -----
 292
 293 func.func @tan(%arg0 : vector<4xf16>) -> () {
 294   // CHECK: spirv.CL.tan {{%.*}} : vector<4xf16>
 295   %2 = spirv.CL.tan %arg0 : vector<4xf16>
 296   return
 297 }
 298
 299 // -----
 300
 301 func.func @atan(%arg0 : f32) -> () {
 302   // CHECK: spirv.CL.atan {{%.*}} : f32
 303   %2 = spirv.CL.atan %arg0 : f32
 304   return
 305 }
 306
 307 // -----
 308
 309 func.func @atan(%arg0 : vector<4xf16>) -> () {
 310   // CHECK: spirv.CL.atan {{%.*}} : vector<4xf16>
 311   %2 = spirv.CL.atan %arg0 : vector<4xf16>
 312   return
 313 }
 314
 315 // -----
 316
 317 func.func @atanh(%arg0 : f32) -> () {
 318   // CHECK: spirv.CL.atanh {{%.*}} : f32
 319   %2 = spirv.CL.atanh %arg0 : f32
 320   return
 321 }
 322
 323 // -----
 324
 325 func.func @atanh(%arg0 : vector<4xf16>) -> () {
 326   // CHECK: spirv.CL.atanh {{%.*}} : vector<4xf16>
 327   %2 = spirv.CL.atanh %arg0 : vector<4xf16>
 328   return
 329 }
 330
 331 // -----
 332
 333 func.func @sinh(%arg0 : f32) -> () {
 334   // CHECK: spirv.CL.sinh {{%.*}} : f32
 335   %2 = spirv.CL.sinh %arg0 : f32
 336   return
 337 }
 338
 339 // -----
 340
 341 func.func @sinh(%arg0 : vector<4xf16>) -> () {
 342   // CHECK: spirv.CL.sinh {{%.*}} : vector<4xf16>
 343   %2 = spirv.CL.sinh %arg0 : vector<4xf16>
 344   return
 345 }
 346
 347 // -----
 348
 349 func.func @cosh(%arg0 : f32) -> () {
 350   // CHECK: spirv.CL.cosh {{%.*}} : f32
 351   %2 = spirv.CL.cosh %arg0 : f32
 352   return
 353 }
 354
 355 // -----
 356
 357 func.func @cosh(%arg0 : vector<4xf16>) -> () {
 358   // CHECK: spirv.CL.cosh {{%.*}} : vector<4xf16>
 359   %2 = spirv.CL.cosh %arg0 : vector<4xf16>
 360   return
 361 }
 362
 363 // -----
 364
 365 func.func @asin(%arg0 : f32) -> () {
 366   // CHECK: spirv.CL.asin {{%.*}} : f32
 367   %2 = spirv.CL.asin %arg0 : f32
 368   return
 369 }
 370
 371 // -----
 372
 373 func.func @asin(%arg0 : vector<4xf16>) -> () {
 374   // CHECK: spirv.CL.asin {{%.*}} : vector<4xf16>
 375   %2 = spirv.CL.asin %arg0 : vector<4xf16>
 376   return
 377 }
 378
 379 // -----
 380
 381 func.func @asinh(%arg0 : f32) -> () {
 382   // CHECK: spirv.CL.asinh {{%.*}} : f32
 383   %2 = spirv.CL.asinh %arg0 : f32
 384   return
 385 }
 386
 387 // -----
 388
 389 func.func @asinh(%arg0 : vector<4xf16>) -> () {
 390   // CHECK: spirv.CL.asinh {{%.*}} : vector<4xf16>
 391   %2 = spirv.CL.asinh %arg0 : vector<4xf16>
 392   return
 393 }
 394
 395 // -----
 396
 397 func.func @acos(%arg0 : f32) -> () {
 398   // CHECK: spirv.CL.acos {{%.*}} : f32
 399   %2 = spirv.CL.acos %arg0 : f32
 400   return
 401 }
 402
 403 // -----
 404
 405 func.func @acos(%arg0 : vector<4xf16>) -> () {
 406   // CHECK: spirv.CL.acos {{%.*}} : vector<4xf16>
 407   %2 = spirv.CL.acos %arg0 : vector<4xf16>
 408   return
 409 }
 410
 411 // -----
 412
 413 func.func @acosh(%arg0 : f32) -> () {
 414   // CHECK: spirv.CL.acosh {{%.*}} : f32
 415   %2 = spirv.CL.acosh %arg0 : f32
 416   return
 417 }
 418
 419 // -----
 420
 421 func.func @acosh(%arg0 : vector<4xf16>) -> () {
 422   // CHECK: spirv.CL.acosh {{%.*}} : vector<4xf16>
 423   %2 = spirv.CL.acosh %arg0 : vector<4xf16>
 424   return
 425 }
 426
 427 // -----
 428
 429 func.func @atan2(%arg0 : f32, %arg1 : f32) -> () {
 430   // CHECK: spirv.CL.atan2 {{%.*}}, {{%.*}} : f32
 431   %2 = spirv.CL.atan2 %arg0, %arg1 : f32
 432   return
 433 }
 434
 435 // -----
 436
 437 func.func @atan2(%arg0 : vector<4xf16>, %arg1 : vector<4xf16>) -> () {
 438   // CHECK: spirv.CL.atan2 {{%.*}}, {{%.*}} : vector<4xf16>
 439   %2 = spirv.CL.atan2 %arg0, %arg1 : vector<4xf16>
 440   return
 441 }
 442