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

   1 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
   2
   3 //===----------------------------------------------------------------------===//
   4 // spirv.GL.Exp
   5 //===----------------------------------------------------------------------===//
   6
   7 func.func @exp(%arg0 : f32) -> () {
   8   // CHECK: spirv.GL.Exp {{%.*}} : f32
   9   %2 = spirv.GL.Exp %arg0 : f32
  10   return
  11 }
  12
  13 func.func @expvec(%arg0 : vector<3xf16>) -> () {
  14   // CHECK: spirv.GL.Exp {{%.*}} : vector<3xf16>
  15   %2 = spirv.GL.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-bit float or vector of 16/32-bit float values}}
  23   %2 = spirv.GL.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-bit float or vector of 16/32-bit float values of length 2/3/4}}
  31   %2 = spirv.GL.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.GL.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.GL.Exp %arg0 :
  48   return
  49 }
  50
  51 // -----
  52
  53 //===----------------------------------------------------------------------===//
  54 // spirv.GL.{F|S|U}{Max|Min}
  55 //===----------------------------------------------------------------------===//
  56
  57 func.func @fmaxmin(%arg0 : f32, %arg1 : f32) {
  58   // CHECK: spirv.GL.FMax {{%.*}}, {{%.*}} : f32
  59   %1 = spirv.GL.FMax %arg0, %arg1 : f32
  60   // CHECK: spirv.GL.FMin {{%.*}}, {{%.*}} : f32
  61   %2 = spirv.GL.FMin %arg0, %arg1 : f32
  62   return
  63 }
  64
  65 func.func @fmaxminvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) {
  66   // CHECK: spirv.GL.FMax {{%.*}}, {{%.*}} : vector<3xf16>
  67   %1 = spirv.GL.FMax %arg0, %arg1 : vector<3xf16>
  68   // CHECK: spirv.GL.FMin {{%.*}}, {{%.*}} : vector<3xf16>
  69   %2 = spirv.GL.FMin %arg0, %arg1 : vector<3xf16>
  70   return
  71 }
  72
  73 func.func @fmaxminf64(%arg0 : f64, %arg1 : f64) {
  74   // CHECK: spirv.GL.FMax {{%.*}}, {{%.*}} : f64
  75   %1 = spirv.GL.FMax %arg0, %arg1 : f64
  76   // CHECK: spirv.GL.FMin {{%.*}}, {{%.*}} : f64
  77   %2 = spirv.GL.FMin %arg0, %arg1 : f64
  78   return
  79 }
  80
  81 func.func @iminmax(%arg0: i32, %arg1: i32) {
  82   // CHECK: spirv.GL.SMax {{%.*}}, {{%.*}} : i32
  83   %1 = spirv.GL.SMax %arg0, %arg1 : i32
  84   // CHECK: spirv.GL.UMax {{%.*}}, {{%.*}} : i32
  85   %2 = spirv.GL.UMax %arg0, %arg1 : i32
  86   // CHECK: spirv.GL.SMin {{%.*}}, {{%.*}} : i32
  87   %3 = spirv.GL.SMin %arg0, %arg1 : i32
  88   // CHECK: spirv.GL.UMin {{%.*}}, {{%.*}} : i32
  89   %4 = spirv.GL.UMin %arg0, %arg1 : i32
  90   return
  91 }
  92
  93 // -----
  94
  95 //===----------------------------------------------------------------------===//
  96 // spirv.GL.InverseSqrt
  97 //===----------------------------------------------------------------------===//
  98
  99 func.func @inversesqrt(%arg0 : f32) -> () {
 100   // CHECK: spirv.GL.InverseSqrt {{%.*}} : f32
 101   %2 = spirv.GL.InverseSqrt %arg0 : f32
 102   return
 103 }
 104
 105 func.func @inversesqrtvec(%arg0 : vector<3xf16>) -> () {
 106   // CHECK: spirv.GL.InverseSqrt {{%.*}} : vector<3xf16>
 107   %2 = spirv.GL.InverseSqrt %arg0 : vector<3xf16>
 108   return
 109 }
 110
 111 // -----
 112
 113 //===----------------------------------------------------------------------===//
 114 // spirv.GL.Sqrt
 115 //===----------------------------------------------------------------------===//
 116
 117 func.func @sqrt(%arg0 : f32) -> () {
 118   // CHECK: spirv.GL.Sqrt {{%.*}} : f32
 119   %2 = spirv.GL.Sqrt %arg0 : f32
 120   return
 121 }
 122
 123 func.func @sqrtvec(%arg0 : vector<3xf16>) -> () {
 124   // CHECK: spirv.GL.Sqrt {{%.*}} : vector<3xf16>
 125   %2 = spirv.GL.Sqrt %arg0 : vector<3xf16>
 126   return
 127 }
 128
 129 //===----------------------------------------------------------------------===//
 130 // spirv.GL.Cos
 131 //===----------------------------------------------------------------------===//
 132
 133 func.func @cos(%arg0 : f32) -> () {
 134   // CHECK: spirv.GL.Cos {{%.*}} : f32
 135   %2 = spirv.GL.Cos %arg0 : f32
 136   return
 137 }
 138
 139 func.func @cosvec(%arg0 : vector<3xf16>) -> () {
 140   // CHECK: spirv.GL.Cos {{%.*}} : vector<3xf16>
 141   %2 = spirv.GL.Cos %arg0 : vector<3xf16>
 142   return
 143 }
 144
 145 //===----------------------------------------------------------------------===//
 146 // spirv.GL.Sin
 147 //===----------------------------------------------------------------------===//
 148
 149 func.func @sin(%arg0 : f32) -> () {
 150   // CHECK: spirv.GL.Sin {{%.*}} : f32
 151   %2 = spirv.GL.Sin %arg0 : f32
 152   return
 153 }
 154
 155 func.func @sinvec(%arg0 : vector<3xf16>) -> () {
 156   // CHECK: spirv.GL.Sin {{%.*}} : vector<3xf16>
 157   %2 = spirv.GL.Sin %arg0 : vector<3xf16>
 158   return
 159 }
 160
 161 //===----------------------------------------------------------------------===//
 162 // spirv.GL.Tan
 163 //===----------------------------------------------------------------------===//
 164
 165 func.func @tan(%arg0 : f32) -> () {
 166   // CHECK: spirv.GL.Tan {{%.*}} : f32
 167   %2 = spirv.GL.Tan %arg0 : f32
 168   return
 169 }
 170
 171 func.func @tanvec(%arg0 : vector<3xf16>) -> () {
 172   // CHECK: spirv.GL.Tan {{%.*}} : vector<3xf16>
 173   %2 = spirv.GL.Tan %arg0 : vector<3xf16>
 174   return
 175 }
 176
 177 //===----------------------------------------------------------------------===//
 178 // spirv.GL.Acos
 179 //===----------------------------------------------------------------------===//
 180
 181 func.func @acos(%arg0 : f32) -> () {
 182   // CHECK: spirv.GL.Acos {{%.*}} : f32
 183   %2 = spirv.GL.Acos %arg0 : f32
 184   return
 185 }
 186
 187 func.func @acosvec(%arg0 : vector<3xf16>) -> () {
 188   // CHECK: spirv.GL.Acos {{%.*}} : vector<3xf16>
 189   %2 = spirv.GL.Acos %arg0 : vector<3xf16>
 190   return
 191 }
 192
 193 //===----------------------------------------------------------------------===//
 194 // spirv.GL.Asin
 195 //===----------------------------------------------------------------------===//
 196
 197 func.func @asin(%arg0 : f32) -> () {
 198   // CHECK: spirv.GL.Asin {{%.*}} : f32
 199   %2 = spirv.GL.Asin %arg0 : f32
 200   return
 201 }
 202
 203 func.func @asinvec(%arg0 : vector<3xf16>) -> () {
 204   // CHECK: spirv.GL.Asin {{%.*}} : vector<3xf16>
 205   %2 = spirv.GL.Asin %arg0 : vector<3xf16>
 206   return
 207 }
 208
 209 //===----------------------------------------------------------------------===//
 210 // spirv.GL.Atan
 211 //===----------------------------------------------------------------------===//
 212
 213 func.func @atan(%arg0 : f32) -> () {
 214   // CHECK: spirv.GL.Atan {{%.*}} : f32
 215   %2 = spirv.GL.Atan %arg0 : f32
 216   return
 217 }
 218
 219 func.func @atanvec(%arg0 : vector<3xf16>) -> () {
 220   // CHECK: spirv.GL.Atan {{%.*}} : vector<3xf16>
 221   %2 = spirv.GL.Atan %arg0 : vector<3xf16>
 222   return
 223 }
 224
 225 //===----------------------------------------------------------------------===//
 226 // spirv.GL.Sinh
 227 //===----------------------------------------------------------------------===//
 228
 229 func.func @sinh(%arg0 : f32) -> () {
 230   // CHECK: spirv.GL.Sinh {{%.*}} : f32
 231   %2 = spirv.GL.Sinh %arg0 : f32
 232   return
 233 }
 234
 235 func.func @sinhvec(%arg0 : vector<3xf16>) -> () {
 236   // CHECK: spirv.GL.Sinh {{%.*}} : vector<3xf16>
 237   %2 = spirv.GL.Sinh %arg0 : vector<3xf16>
 238   return
 239 }
 240
 241 //===----------------------------------------------------------------------===//
 242 // spirv.GL.Cosh
 243 //===----------------------------------------------------------------------===//
 244
 245 func.func @cosh(%arg0 : f32) -> () {
 246   // CHECK: spirv.GL.Cosh {{%.*}} : f32
 247   %2 = spirv.GL.Cosh %arg0 : f32
 248   return
 249 }
 250
 251 func.func @coshvec(%arg0 : vector<3xf16>) -> () {
 252   // CHECK: spirv.GL.Cosh {{%.*}} : vector<3xf16>
 253   %2 = spirv.GL.Cosh %arg0 : vector<3xf16>
 254   return
 255 }
 256
 257 //===----------------------------------------------------------------------===//
 258 // spirv.GL.Pow
 259 //===----------------------------------------------------------------------===//
 260
 261 func.func @pow(%arg0 : f32, %arg1 : f32) -> () {
 262   // CHECK: spirv.GL.Pow {{%.*}}, {{%.*}} : f32
 263   %2 = spirv.GL.Pow %arg0, %arg1 : f32
 264   return
 265 }
 266
 267 func.func @powvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) -> () {
 268   // CHECK: spirv.GL.Pow {{%.*}}, {{%.*}} : vector<3xf16>
 269   %2 = spirv.GL.Pow %arg0, %arg1 : vector<3xf16>
 270   return
 271 }
 272
 273 // -----
 274
 275 //===----------------------------------------------------------------------===//
 276 // spirv.GL.Round
 277 //===----------------------------------------------------------------------===//
 278
 279 func.func @round(%arg0 : f32) -> () {
 280   // CHECK: spirv.GL.Round {{%.*}} : f32
 281   %2 = spirv.GL.Round %arg0 : f32
 282   return
 283 }
 284
 285 func.func @roundvec(%arg0 : vector<3xf16>) -> () {
 286   // CHECK: spirv.GL.Round {{%.*}} : vector<3xf16>
 287   %2 = spirv.GL.Round %arg0 : vector<3xf16>
 288   return
 289 }
 290
 291 //===----------------------------------------------------------------------===//
 292 // spirv.GL.RoundEven
 293 //===----------------------------------------------------------------------===//
 294
 295 func.func @round_even(%arg0 : f32) -> () {
 296   // CHECK: spirv.GL.RoundEven {{%.*}} : f32
 297   %2 = spirv.GL.RoundEven %arg0 : f32
 298   return
 299 }
 300
 301 func.func @round_even_vec(%arg0 : vector<3xf16>) -> () {
 302   // CHECK: spirv.GL.RoundEven {{%.*}} : vector<3xf16>
 303   %2 = spirv.GL.RoundEven %arg0 : vector<3xf16>
 304   return
 305 }
 306
 307 // -----
 308
 309 //===----------------------------------------------------------------------===//
 310 // spirv.GL.FClamp
 311 //===----------------------------------------------------------------------===//
 312
 313 func.func @fclamp(%arg0 : f32, %min : f32, %max : f32) -> () {
 314   // CHECK: spirv.GL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
 315   %2 = spirv.GL.FClamp %arg0, %min, %max : f32
 316   return
 317 }
 318
 319 // -----
 320
 321 func.func @fclamp(%arg0 : vector<3xf32>, %min : vector<3xf32>, %max : vector<3xf32>) -> () {
 322   // CHECK: spirv.GL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
 323   %2 = spirv.GL.FClamp %arg0, %min, %max : vector<3xf32>
 324   return
 325 }
 326
 327 // -----
 328
 329 //===----------------------------------------------------------------------===//
 330 // spirv.GL.UClamp
 331 //===----------------------------------------------------------------------===//
 332
 333 func.func @uclamp(%arg0 : ui32, %min : ui32, %max : ui32) -> () {
 334   // CHECK: spirv.GL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : ui32
 335   %2 = spirv.GL.UClamp %arg0, %min, %max : ui32
 336   return
 337 }
 338
 339 // -----
 340
 341 func.func @uclamp(%arg0 : vector<4xi32>, %min : vector<4xi32>, %max : vector<4xi32>) -> () {
 342   // CHECK: spirv.GL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xi32>
 343   %2 = spirv.GL.UClamp %arg0, %min, %max : vector<4xi32>
 344   return
 345 }
 346
 347 // -----
 348
 349 func.func @uclamp(%arg0 : si32, %min : si32, %max : si32) -> () {
 350   // CHECK: spirv.GL.UClamp
 351   %2 = spirv.GL.UClamp %arg0, %min, %max : si32
 352   return
 353 }
 354
 355 // -----
 356
 357 //===----------------------------------------------------------------------===//
 358 // spirv.GL.SClamp
 359 //===----------------------------------------------------------------------===//
 360
 361 func.func @sclamp(%arg0 : si32, %min : si32, %max : si32) -> () {
 362   // CHECK: spirv.GL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32
 363   %2 = spirv.GL.SClamp %arg0, %min, %max : si32
 364   return
 365 }
 366
 367 // -----
 368
 369 func.func @sclamp(%arg0 : vector<4xsi32>, %min : vector<4xsi32>, %max : vector<4xsi32>) -> () {
 370   // CHECK: spirv.GL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xsi32>
 371   %2 = spirv.GL.SClamp %arg0, %min, %max : vector<4xsi32>
 372   return
 373 }
 374
 375 // -----
 376
 377 func.func @sclamp(%arg0 : i32, %min : i32, %max : i32) -> () {
 378   // CHECK: spirv.GL.SClamp
 379   %2 = spirv.GL.SClamp %arg0, %min, %max : i32
 380   return
 381 }
 382
 383 // -----
 384
 385 //===----------------------------------------------------------------------===//
 386 // spirv.GL.Fma
 387 //===----------------------------------------------------------------------===//
 388
 389 func.func @fma(%a : f32, %b : f32, %c : f32) -> () {
 390   // CHECK: spirv.GL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
 391   %2 = spirv.GL.Fma %a, %b, %c : f32
 392   return
 393 }
 394
 395 // -----
 396
 397 func.func @fma(%a : vector<3xf32>, %b : vector<3xf32>, %c : vector<3xf32>) -> () {
 398   // CHECK: spirv.GL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
 399   %2 = spirv.GL.Fma %a, %b, %c : vector<3xf32>
 400   return
 401 }
 402 // -----
 403
 404 //===----------------------------------------------------------------------===//
 405 // spirv.GL.FrexpStruct
 406 //===----------------------------------------------------------------------===//
 407
 408 func.func @frexp_struct(%arg0 : f32) -> () {
 409   // CHECK: spirv.GL.FrexpStruct {{%.*}} : f32 -> !spirv.struct<(f32, i32)>
 410   %2 = spirv.GL.FrexpStruct %arg0 : f32 -> !spirv.struct<(f32, i32)>
 411   return
 412 }
 413
 414 func.func @frexp_struct_64(%arg0 : f64) -> () {
 415   // CHECK: spirv.GL.FrexpStruct {{%.*}} : f64 -> !spirv.struct<(f64, i32)>
 416   %2 = spirv.GL.FrexpStruct %arg0 : f64 -> !spirv.struct<(f64, i32)>
 417   return
 418 }
 419
 420 func.func @frexp_struct_vec(%arg0 : vector<3xf32>) -> () {
 421   // CHECK: spirv.GL.FrexpStruct {{%.*}} : vector<3xf32> -> !spirv.struct<(vector<3xf32>, vector<3xi32>)>
 422   %2 = spirv.GL.FrexpStruct %arg0 : vector<3xf32> -> !spirv.struct<(vector<3xf32>, vector<3xi32>)>
 423   return
 424 }
 425
 426 // -----
 427
 428 func.func @frexp_struct_mismatch_type(%arg0 : f32) -> () {
 429   // expected-error @+1 {{member zero of the resulting struct type must be the same type as the operand}}
 430   %2 = spirv.GL.FrexpStruct %arg0 : f32 -> !spirv.struct<(vector<3xf32>, i32)>
 431   return
 432 }
 433
 434 // -----
 435
 436 func.func @frexp_struct_wrong_type(%arg0 : i32) -> () {
 437   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
 438   %2 = spirv.GL.FrexpStruct %arg0 : i32 -> !spirv.struct<(i32, i32)>
 439   return
 440 }
 441
 442 // -----
 443
 444 func.func @frexp_struct_mismatch_num_components(%arg0 : vector<3xf32>) -> () {
 445   // expected-error @+1 {{member one of the resulting struct type must have the same number of components as the operand type}}
 446   %2 = spirv.GL.FrexpStruct %arg0 : vector<3xf32> -> !spirv.struct<(vector<3xf32>, vector<2xi32>)>
 447   return
 448 }
 449
 450 // -----
 451
 452 func.func @frexp_struct_not_i32(%arg0 : f32) -> () {
 453   // expected-error @+1 {{member one of the resulting struct type must be a scalar or vector of 32 bit integer type}}
 454   %2 = spirv.GL.FrexpStruct %arg0 : f32 -> !spirv.struct<(f32, i64)>
 455   return
 456 }
 457
 458 // -----
 459
 460 //===----------------------------------------------------------------------===//
 461 // spirv.GL.Ldexp
 462 //===----------------------------------------------------------------------===//
 463
 464 func.func @ldexp(%arg0 : f32, %arg1 : i32) -> () {
 465   // CHECK: {{%.*}} = spirv.GL.Ldexp {{%.*}} : f32, {{%.*}} : i32 -> f32
 466   %0 = spirv.GL.Ldexp %arg0 : f32, %arg1 : i32 -> f32
 467   return
 468 }
 469
 470 // -----
 471 func.func @ldexp_vec(%arg0 : vector<3xf32>, %arg1 : vector<3xi32>) -> () {
 472   // CHECK: {{%.*}} = spirv.GL.Ldexp {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xi32> -> vector<3xf32>
 473   %0 = spirv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<3xi32> -> vector<3xf32>
 474   return
 475 }
 476
 477 // -----
 478
 479 func.func @ldexp_wrong_type_scalar(%arg0 : f32, %arg1 : vector<2xi32>) -> () {
 480   // expected-error @+1 {{operands must both be scalars or vectors}}
 481   %0 = spirv.GL.Ldexp %arg0 : f32, %arg1 : vector<2xi32> -> f32
 482   return
 483 }
 484
 485 // -----
 486
 487 func.func @ldexp_wrong_type_vec_1(%arg0 : vector<3xf32>, %arg1 : i32) -> () {
 488   // expected-error @+1 {{operands must both be scalars or vectors}}
 489   %0 = spirv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : i32 -> vector<3xf32>
 490   return
 491 }
 492
 493 // -----
 494
 495 func.func @ldexp_wrong_type_vec_2(%arg0 : vector<3xf32>, %arg1 : vector<2xi32>) -> () {
 496   // expected-error @+1 {{operands must have the same number of elements}}
 497   %0 = spirv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<2xi32> -> vector<3xf32>
 498   return
 499 }
 500
 501 // -----
 502
 503 //===----------------------------------------------------------------------===//
 504 // spirv.GL.FMix
 505 //===----------------------------------------------------------------------===//
 506
 507 func.func @fmix(%arg0 : f32, %arg1 : f32, %arg2 : f32) -> () {
 508   // CHECK: {{%.*}} = spirv.GL.FMix {{%.*}} : f32, {{%.*}} : f32, {{%.*}} : f32 -> f32
 509   %0 = spirv.GL.FMix %arg0 : f32, %arg1 : f32, %arg2 : f32 -> f32
 510   return
 511 }
 512
 513 func.func @fmix_vector(%arg0 : vector<3xf32>, %arg1 : vector<3xf32>, %arg2 : vector<3xf32>) -> () {
 514   // CHECK: {{%.*}} = spirv.GL.FMix {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32> -> vector<3xf32>
 515   %0 = spirv.GL.FMix %arg0 : vector<3xf32>, %arg1 : vector<3xf32>, %arg2 : vector<3xf32> -> vector<3xf32>
 516   return
 517 }
 518
 519 // -----
 520
 521 //===----------------------------------------------------------------------===//
 522 // spirv.GL.Exp
 523 //===----------------------------------------------------------------------===//
 524
 525 func.func @findumsb(%arg0 : i32) -> () {
 526   // CHECK: spirv.GL.FindUMsb {{%.*}} : i32
 527   %2 = spirv.GL.FindUMsb %arg0 : i32
 528   return
 529 }
 530
 531 func.func @findumsb_vector(%arg0 : vector<3xi32>) -> () {
 532   // CHECK: spirv.GL.FindUMsb {{%.*}} : vector<3xi32>
 533   %2 = spirv.GL.FindUMsb %arg0 : vector<3xi32>
 534   return
 535 }
 536
 537 // -----
 538
 539 func.func @findumsb(%arg0 : i64) -> () {
 540   // expected-error @+1 {{operand #0 must be Int32 or vector of Int32}}
 541   %2 = spirv.GL.FindUMsb %arg0 : i64
 542   return
 543 }