mlir/test/Dialect/SPIRV/IR/non-uniform-ops.mlir

   1 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
   2
   3 //===----------------------------------------------------------------------===//
   4 // spirv.GroupNonUniformBallot
   5 //===----------------------------------------------------------------------===//
   6
   7 func.func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> {
   8   // CHECK: %{{.*}} = spirv.GroupNonUniformBallot <Workgroup> %{{.*}}: vector<4xi32>
   9   %0 = spirv.GroupNonUniformBallot <Workgroup> %predicate : vector<4xi32>
  10   return %0: vector<4xi32>
  11 }
  12
  13 // -----
  14
  15 func.func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> {
  16   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
  17   %0 = spirv.GroupNonUniformBallot <Device> %predicate : vector<4xi32>
  18   return %0: vector<4xi32>
  19 }
  20
  21 // -----
  22
  23 func.func @group_non_uniform_ballot(%predicate: i1) -> vector<4xsi32> {
  24   // expected-error @+1 {{op result #0 must be vector of 8/16/32/64-bit signless/unsigned integer values of length 4, but got 'vector<4xsi32>'}}
  25   %0 = spirv.GroupNonUniformBallot <Workgroup> %predicate : vector<4xsi32>
  26   return %0: vector<4xsi32>
  27 }
  28
  29 // -----
  30
  31 //===----------------------------------------------------------------------===//
  32 // spirv.GroupNonUniformBallotFindLSB
  33 //===----------------------------------------------------------------------===//
  34
  35 func.func @group_non_uniform_ballot_find_lsb(%value : vector<4xi32>) -> i32 {
  36   // CHECK: %{{.*}} = spirv.GroupNonUniformBallotFindLSB <Subgroup> %{{.*}}: vector<4xi32>, i32
  37   %0 = spirv.GroupNonUniformBallotFindLSB <Subgroup> %value : vector<4xi32>, i32
  38   return %0: i32
  39 }
  40
  41 // -----
  42
  43 func.func @group_non_uniform_ballot_find_lsb(%value : vector<4xi32>) -> i32 {
  44   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
  45   %0 = spirv.GroupNonUniformBallotFindLSB <Device> %value : vector<4xi32>, i32
  46   return %0: i32
  47 }
  48
  49 // -----
  50
  51 func.func @group_non_uniform_ballot_find_lsb(%value : vector<4xi32>) -> si32 {
  52   // expected-error @+1 {{op result #0 must be 8/16/32/64-bit signless/unsigned integer, but got 'si32'}}
  53   %0 = spirv.GroupNonUniformBallotFindLSB <Subgroup> %value : vector<4xi32>, si32
  54   return %0: si32
  55 }
  56
  57 // -----
  58
  59 //===----------------------------------------------------------------------===//
  60 // spirv.GroupNonUniformBallotFindLSB
  61 //===----------------------------------------------------------------------===//
  62
  63 func.func @group_non_uniform_ballot_find_msb(%value : vector<4xi32>) -> i32 {
  64   // CHECK: %{{.*}} = spirv.GroupNonUniformBallotFindMSB <Subgroup> %{{.*}}: vector<4xi32>, i32
  65   %0 = spirv.GroupNonUniformBallotFindMSB <Subgroup> %value : vector<4xi32>, i32
  66   return %0: i32
  67 }
  68
  69 // -----
  70
  71 func.func @group_non_uniform_ballot_find_msb(%value : vector<4xi32>) -> i32 {
  72   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
  73   %0 = spirv.GroupNonUniformBallotFindMSB <Device> %value : vector<4xi32>, i32
  74   return %0: i32
  75 }
  76
  77 // -----
  78
  79 func.func @group_non_uniform_ballot_find_msb(%value : vector<4xi32>) -> si32 {
  80   // expected-error @+1 {{op result #0 must be 8/16/32/64-bit signless/unsigned integer, but got 'si32'}}
  81   %0 = spirv.GroupNonUniformBallotFindMSB <Subgroup> %value : vector<4xi32>, si32
  82   return %0: si32
  83 }
  84
  85 // -----
  86
  87 //===----------------------------------------------------------------------===//
  88 // spirv.NonUniformGroupBroadcast
  89 //===----------------------------------------------------------------------===//
  90
  91 func.func @group_non_uniform_broadcast_scalar(%value: f32) -> f32 {
  92   %one = spirv.Constant 1 : i32
  93   // CHECK: spirv.GroupNonUniformBroadcast <Workgroup> %{{.*}}, %{{.*}} : f32, i32
  94   %0 = spirv.GroupNonUniformBroadcast <Workgroup> %value, %one : f32, i32
  95   return %0: f32
  96 }
  97
  98 // -----
  99
 100 func.func @group_non_uniform_broadcast_vector(%value: vector<4xf32>) -> vector<4xf32> {
 101   %one = spirv.Constant 1 : i32
 102   // CHECK: spirv.GroupNonUniformBroadcast <Subgroup> %{{.*}}, %{{.*}} : vector<4xf32>, i32
 103   %0 = spirv.GroupNonUniformBroadcast <Subgroup> %value, %one : vector<4xf32>, i32
 104   return %0: vector<4xf32>
 105 }
 106
 107 // -----
 108
 109 func.func @group_non_uniform_broadcast_negative_scope(%value: f32, %localid: i32 ) -> f32 {
 110   %one = spirv.Constant 1 : i32
 111   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
 112   %0 = spirv.GroupNonUniformBroadcast <Device> %value, %one : f32, i32
 113   return %0: f32
 114 }
 115
 116 // -----
 117
 118 func.func @group_non_uniform_broadcast_negative_non_const(%value: f32, %localid: i32) -> f32 {
 119   // expected-error @+1 {{id must be the result of a constant op}}
 120   %0 = spirv.GroupNonUniformBroadcast <Subgroup> %value, %localid : f32, i32
 121   return %0: f32
 122 }
 123
 124 // -----
 125
 126 //===----------------------------------------------------------------------===//
 127 // spirv.GroupNonUniformElect
 128 //===----------------------------------------------------------------------===//
 129
 130 // CHECK-LABEL: @group_non_uniform_elect
 131 func.func @group_non_uniform_elect() -> i1 {
 132   // CHECK: %{{.+}} = spirv.GroupNonUniformElect <Workgroup> : i1
 133   %0 = spirv.GroupNonUniformElect <Workgroup> : i1
 134   return %0: i1
 135 }
 136
 137 // -----
 138
 139 func.func @group_non_uniform_elect() -> i1 {
 140   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
 141   %0 = spirv.GroupNonUniformElect <CrossDevice> : i1
 142   return %0: i1
 143 }
 144
 145 // -----
 146
 147 //===----------------------------------------------------------------------===//
 148 // spirv.GroupNonUniformFAdd
 149 //===----------------------------------------------------------------------===//
 150
 151 // CHECK-LABEL: @group_non_uniform_fadd_reduce
 152 func.func @group_non_uniform_fadd_reduce(%val: f32) -> f32 {
 153   // CHECK: %{{.+}} = spirv.GroupNonUniformFAdd <Workgroup> <Reduce> %{{.+}} : f32 -> f32
 154   %0 = spirv.GroupNonUniformFAdd <Workgroup> <Reduce> %val : f32 -> f32
 155   return %0: f32
 156 }
 157
 158 // CHECK-LABEL: @group_non_uniform_fadd_clustered_reduce
 159 func.func @group_non_uniform_fadd_clustered_reduce(%val: vector<2xf32>) -> vector<2xf32> {
 160   %four = spirv.Constant 4 : i32
 161   // CHECK: %{{.+}} = spirv.GroupNonUniformFAdd <Workgroup> <ClusteredReduce> %{{.+}} cluster_size(%{{.+}}) : vector<2xf32>, i32 -> vector<2xf32>
 162   %0 = spirv.GroupNonUniformFAdd <Workgroup> <ClusteredReduce> %val cluster_size(%four) : vector<2xf32>, i32 -> vector<2xf32>
 163   return %0: vector<2xf32>
 164 }
 165
 166 //===----------------------------------------------------------------------===//
 167 // spirv.GroupNonUniformFMul
 168 //===----------------------------------------------------------------------===//
 169
 170 // CHECK-LABEL: @group_non_uniform_fmul_reduce
 171 func.func @group_non_uniform_fmul_reduce(%val: f32) -> f32 {
 172   // CHECK: %{{.+}} = spirv.GroupNonUniformFMul <Workgroup> <Reduce> %{{.+}} : f32 -> f32
 173   %0 = spirv.GroupNonUniformFMul <Workgroup> <Reduce> %val : f32 -> f32
 174   return %0: f32
 175 }
 176
 177 // CHECK-LABEL: @group_non_uniform_fmul_clustered_reduce
 178 func.func @group_non_uniform_fmul_clustered_reduce(%val: vector<2xf32>) -> vector<2xf32> {
 179   %four = spirv.Constant 4 : i32
 180   // CHECK: %{{.+}} = spirv.GroupNonUniformFMul <Workgroup> <ClusteredReduce> %{{.+}} cluster_size(%{{.+}}) : vector<2xf32>, i32 -> vector<2xf32>
 181   %0 = spirv.GroupNonUniformFMul <Workgroup> <ClusteredReduce> %val cluster_size(%four) : vector<2xf32>, i32 -> vector<2xf32>
 182   return %0: vector<2xf32>
 183 }
 184
 185 // -----
 186
 187 //===----------------------------------------------------------------------===//
 188 // spirv.GroupNonUniformFMax
 189 //===----------------------------------------------------------------------===//
 190
 191 // CHECK-LABEL: @group_non_uniform_fmax_reduce
 192 func.func @group_non_uniform_fmax_reduce(%val: f32) -> f32 {
 193   // CHECK: %{{.+}} = spirv.GroupNonUniformFMax <Workgroup> <Reduce> %{{.+}} : f32 -> f32
 194   %0 = spirv.GroupNonUniformFMax <Workgroup> <Reduce> %val : f32 -> f32
 195   return %0: f32
 196 }
 197
 198 // -----
 199
 200 //===----------------------------------------------------------------------===//
 201 // spirv.GroupNonUniformFMin
 202 //===----------------------------------------------------------------------===//
 203
 204 // CHECK-LABEL: @group_non_uniform_fmin_reduce
 205 func.func @group_non_uniform_fmin_reduce(%val: f32) -> f32 {
 206   // CHECK: %{{.+}} = spirv.GroupNonUniformFMin <Workgroup> <Reduce> %{{.+}} : f32 -> f32
 207   %0 = spirv.GroupNonUniformFMin <Workgroup> <Reduce> %val : f32 -> f32
 208   return %0: f32
 209 }
 210
 211 // -----
 212
 213 //===----------------------------------------------------------------------===//
 214 // spirv.GroupNonUniformIAdd
 215 //===----------------------------------------------------------------------===//
 216
 217 // CHECK-LABEL: @group_non_uniform_iadd_reduce
 218 func.func @group_non_uniform_iadd_reduce(%val: i32) -> i32 {
 219   // CHECK: %{{.+}} = spirv.GroupNonUniformIAdd <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 220   %0 = spirv.GroupNonUniformIAdd <Workgroup> <Reduce> %val : i32 -> i32
 221   return %0: i32
 222 }
 223
 224 // CHECK-LABEL: @group_non_uniform_iadd_clustered_reduce
 225 func.func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
 226   %four = spirv.Constant 4 : i32
 227   // CHECK: %{{.+}} = spirv.GroupNonUniformIAdd <Workgroup> <ClusteredReduce> %{{.+}} cluster_size(%{{.+}}) : vector<2xi32>, i32 -> vector<2xi32>
 228   %0 = spirv.GroupNonUniformIAdd <Workgroup> <ClusteredReduce> %val cluster_size(%four) : vector<2xi32>, i32 -> vector<2xi32>
 229   return %0: vector<2xi32>
 230 }
 231
 232 // -----
 233
 234 func.func @group_non_uniform_iadd_reduce(%val: i32) -> i32 {
 235   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
 236   %0 = spirv.GroupNonUniformIAdd <Device> <Reduce> %val : i32 -> i32
 237   return %0: i32
 238 }
 239
 240 // -----
 241
 242 func.func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
 243   // expected-error @+1 {{cluster size operand must be provided for 'ClusteredReduce' group operation}}
 244   %0 = spirv.GroupNonUniformIAdd <Workgroup> <ClusteredReduce> %val : vector<2xi32> -> vector<2xi32>
 245   return %0: vector<2xi32>
 246 }
 247
 248 // -----
 249
 250 func.func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>, %size: i32) -> vector<2xi32> {
 251   // expected-error @+1 {{cluster size operand must come from a constant op}}
 252   %0 = spirv.GroupNonUniformIAdd <Workgroup> <ClusteredReduce> %val cluster_size(%size) : vector<2xi32>, i32 -> vector<2xi32>
 253   return %0: vector<2xi32>
 254 }
 255
 256 // -----
 257
 258 func.func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
 259   %five = spirv.Constant 5 : i32
 260   // expected-error @+1 {{cluster size operand must be a power of two}}
 261   %0 = spirv.GroupNonUniformIAdd <Workgroup> <ClusteredReduce> %val cluster_size(%five) : vector<2xi32>, i32 -> vector<2xi32>
 262   return %0: vector<2xi32>
 263 }
 264
 265 // -----
 266
 267 //===----------------------------------------------------------------------===//
 268 // spirv.GroupNonUniformIMul
 269 //===----------------------------------------------------------------------===//
 270
 271 // CHECK-LABEL: @group_non_uniform_imul_reduce
 272 func.func @group_non_uniform_imul_reduce(%val: i32) -> i32 {
 273   // CHECK: %{{.+}} = spirv.GroupNonUniformIMul <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 274   %0 = spirv.GroupNonUniformIMul <Workgroup> <Reduce> %val : i32 -> i32
 275   return %0: i32
 276 }
 277
 278 // CHECK-LABEL: @group_non_uniform_imul_clustered_reduce
 279 func.func @group_non_uniform_imul_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
 280   %four = spirv.Constant 4 : i32
 281   // CHECK: %{{.+}} = spirv.GroupNonUniformIMul <Workgroup> <ClusteredReduce> %{{.+}} cluster_size(%{{.+}}) : vector<2xi32>, i32 -> vector<2xi32>
 282   %0 = spirv.GroupNonUniformIMul <Workgroup> <ClusteredReduce> %val cluster_size(%four) : vector<2xi32>, i32 -> vector<2xi32>
 283   return %0: vector<2xi32>
 284 }
 285
 286 // -----
 287
 288 //===----------------------------------------------------------------------===//
 289 // spirv.GroupNonUniformSMax
 290 //===----------------------------------------------------------------------===//
 291
 292 // CHECK-LABEL: @group_non_uniform_smax_reduce
 293 func.func @group_non_uniform_smax_reduce(%val: i32) -> i32 {
 294   // CHECK: %{{.+}} = spirv.GroupNonUniformSMax <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 295   %0 = spirv.GroupNonUniformSMax <Workgroup> <Reduce> %val : i32 -> i32
 296   return %0: i32
 297 }
 298
 299 // -----
 300
 301 //===----------------------------------------------------------------------===//
 302 // spirv.GroupNonUniformSMin
 303 //===----------------------------------------------------------------------===//
 304
 305 // CHECK-LABEL: @group_non_uniform_smin_reduce
 306 func.func @group_non_uniform_smin_reduce(%val: i32) -> i32 {
 307   // CHECK: %{{.+}} = spirv.GroupNonUniformSMin <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 308   %0 = spirv.GroupNonUniformSMin <Workgroup> <Reduce> %val : i32 -> i32
 309   return %0: i32
 310 }
 311
 312 // -----
 313
 314 //===----------------------------------------------------------------------===//
 315 // spirv.GroupNonUniformShuffle
 316 //===----------------------------------------------------------------------===//
 317
 318 // CHECK-LABEL: @group_non_uniform_shuffle1
 319 func.func @group_non_uniform_shuffle1(%val: f32, %id: i32) -> f32 {
 320   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffle <Subgroup> %{{.+}}, %{{.+}} : f32, i32
 321   %0 = spirv.GroupNonUniformShuffle <Subgroup> %val, %id : f32, i32
 322   return %0: f32
 323 }
 324
 325 // CHECK-LABEL: @group_non_uniform_shuffle2
 326 func.func @group_non_uniform_shuffle2(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 327   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffle <Subgroup> %{{.+}}, %{{.+}} : vector<2xf32>, i32
 328   %0 = spirv.GroupNonUniformShuffle <Subgroup> %val, %id : vector<2xf32>, i32
 329   return %0: vector<2xf32>
 330 }
 331
 332 // -----
 333
 334 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 335   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
 336   %0 = spirv.GroupNonUniformShuffle <Device> %val, %id : vector<2xf32>, i32
 337   return %0: vector<2xf32>
 338 }
 339
 340 // -----
 341
 342 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: si32) -> vector<2xf32> {
 343   // expected-error @+1 {{second operand must be a singless/unsigned integer}}
 344   %0 = spirv.GroupNonUniformShuffle <Subgroup> %val, %id : vector<2xf32>, si32
 345   return %0: vector<2xf32>
 346 }
 347
 348 // -----
 349
 350 //===----------------------------------------------------------------------===//
 351 // spirv.GroupNonUniformShuffleXor
 352 //===----------------------------------------------------------------------===//
 353
 354 // CHECK-LABEL: @group_non_uniform_shuffle1
 355 func.func @group_non_uniform_shuffle1(%val: f32, %id: i32) -> f32 {
 356   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffleXor <Subgroup> %{{.+}}, %{{.+}} : f32, i32
 357   %0 = spirv.GroupNonUniformShuffleXor <Subgroup> %val, %id : f32, i32
 358   return %0: f32
 359 }
 360
 361 // CHECK-LABEL: @group_non_uniform_shuffle2
 362 func.func @group_non_uniform_shuffle2(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 363   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffleXor <Subgroup> %{{.+}}, %{{.+}} : vector<2xf32>, i32
 364   %0 = spirv.GroupNonUniformShuffleXor <Subgroup> %val, %id : vector<2xf32>, i32
 365   return %0: vector<2xf32>
 366 }
 367
 368 // -----
 369
 370 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 371   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
 372   %0 = spirv.GroupNonUniformShuffleXor <Device> %val, %id : vector<2xf32>, i32
 373   return %0: vector<2xf32>
 374 }
 375
 376 // -----
 377
 378 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: si32) -> vector<2xf32> {
 379   // expected-error @+1 {{second operand must be a singless/unsigned integer}}
 380   %0 = spirv.GroupNonUniformShuffleXor <Subgroup> %val, %id : vector<2xf32>, si32
 381   return %0: vector<2xf32>
 382 }
 383
 384 // -----
 385
 386 //===----------------------------------------------------------------------===//
 387 // spirv.GroupNonUniformShuffleUp
 388 //===----------------------------------------------------------------------===//
 389
 390 // CHECK-LABEL: @group_non_uniform_shuffle1
 391 func.func @group_non_uniform_shuffle1(%val: f32, %id: i32) -> f32 {
 392   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffleUp <Subgroup> %{{.+}}, %{{.+}} : f32, i32
 393   %0 = spirv.GroupNonUniformShuffleUp <Subgroup> %val, %id : f32, i32
 394   return %0: f32
 395 }
 396
 397 // CHECK-LABEL: @group_non_uniform_shuffle2
 398 func.func @group_non_uniform_shuffle2(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 399   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffleUp <Subgroup> %{{.+}}, %{{.+}} : vector<2xf32>, i32
 400   %0 = spirv.GroupNonUniformShuffleUp <Subgroup> %val, %id : vector<2xf32>, i32
 401   return %0: vector<2xf32>
 402 }
 403
 404 // -----
 405
 406 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 407   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
 408   %0 = spirv.GroupNonUniformShuffleUp <Device> %val, %id : vector<2xf32>, i32
 409   return %0: vector<2xf32>
 410 }
 411
 412 // -----
 413
 414 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: si32) -> vector<2xf32> {
 415   // expected-error @+1 {{second operand must be a singless/unsigned integer}}
 416   %0 = spirv.GroupNonUniformShuffleUp <Subgroup> %val, %id : vector<2xf32>, si32
 417   return %0: vector<2xf32>
 418 }
 419
 420 // -----
 421
 422 //===----------------------------------------------------------------------===//
 423 // spirv.GroupNonUniformShuffleDown
 424 //===----------------------------------------------------------------------===//
 425
 426 // CHECK-LABEL: @group_non_uniform_shuffle1
 427 func.func @group_non_uniform_shuffle1(%val: f32, %id: i32) -> f32 {
 428   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffleDown <Subgroup> %{{.+}}, %{{.+}} : f32, i32
 429   %0 = spirv.GroupNonUniformShuffleDown <Subgroup> %val, %id : f32, i32
 430   return %0: f32
 431 }
 432
 433 // CHECK-LABEL: @group_non_uniform_shuffle2
 434 func.func @group_non_uniform_shuffle2(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 435   // CHECK: %{{.+}} = spirv.GroupNonUniformShuffleDown <Subgroup> %{{.+}}, %{{.+}} : vector<2xf32>, i32
 436   %0 = spirv.GroupNonUniformShuffleDown <Subgroup> %val, %id : vector<2xf32>, i32
 437   return %0: vector<2xf32>
 438 }
 439
 440 // -----
 441
 442 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: i32) -> vector<2xf32> {
 443   // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
 444   %0 = spirv.GroupNonUniformShuffleDown <Device> %val, %id : vector<2xf32>, i32
 445   return %0: vector<2xf32>
 446 }
 447
 448 // -----
 449
 450 func.func @group_non_uniform_shuffle(%val: vector<2xf32>, %id: si32) -> vector<2xf32> {
 451   // expected-error @+1 {{second operand must be a singless/unsigned integer}}
 452   %0 = spirv.GroupNonUniformShuffleDown <Subgroup> %val, %id : vector<2xf32>, si32
 453   return %0: vector<2xf32>
 454 }
 455
 456 // -----
 457
 458 //===----------------------------------------------------------------------===//
 459 // spirv.GroupNonUniformUMax
 460 //===----------------------------------------------------------------------===//
 461
 462 // CHECK-LABEL: @group_non_uniform_umax_reduce
 463 func.func @group_non_uniform_umax_reduce(%val: i32) -> i32 {
 464   // CHECK: %{{.+}} = spirv.GroupNonUniformUMax <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 465   %0 = spirv.GroupNonUniformUMax <Workgroup> <Reduce> %val : i32 -> i32
 466   return %0: i32
 467 }
 468
 469 // -----
 470
 471 //===----------------------------------------------------------------------===//
 472 // spirv.GroupNonUniformUMin
 473 //===----------------------------------------------------------------------===//
 474
 475 // CHECK-LABEL: @group_non_uniform_umin_reduce
 476 func.func @group_non_uniform_umin_reduce(%val: i32) -> i32 {
 477   // CHECK: %{{.+}} = spirv.GroupNonUniformUMin <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 478   %0 = spirv.GroupNonUniformUMin <Workgroup> <Reduce> %val : i32 -> i32
 479   return %0: i32
 480 }
 481
 482 // -----
 483
 484 //===----------------------------------------------------------------------===//
 485 // spirv.GroupNonUniformBitwiseAnd
 486 //===----------------------------------------------------------------------===//
 487
 488 // CHECK-LABEL: @group_non_uniform_bitwise_and
 489 func.func @group_non_uniform_bitwise_and(%val: i32) -> i32 {
 490   // CHECK: %{{.+}} = spirv.GroupNonUniformBitwiseAnd <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 491   %0 = spirv.GroupNonUniformBitwiseAnd <Workgroup> <Reduce> %val : i32 -> i32
 492   return %0: i32
 493 }
 494
 495 // -----
 496
 497 func.func @group_non_uniform_bitwise_and(%val: i1) -> i1 {
 498   // expected-error @+1 {{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/8/16, but got 'i1'}}
 499   %0 = spirv.GroupNonUniformBitwiseAnd <Workgroup> <Reduce> %val : i1 -> i1
 500   return %0: i1
 501 }
 502
 503 // -----
 504
 505 //===----------------------------------------------------------------------===//
 506 // spirv.GroupNonUniformBitwiseOr
 507 //===----------------------------------------------------------------------===//
 508
 509 // CHECK-LABEL: @group_non_uniform_bitwise_or
 510 func.func @group_non_uniform_bitwise_or(%val: i32) -> i32 {
 511   // CHECK: %{{.+}} = spirv.GroupNonUniformBitwiseOr <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 512   %0 = spirv.GroupNonUniformBitwiseOr <Workgroup> <Reduce> %val : i32 -> i32
 513   return %0: i32
 514 }
 515
 516 // -----
 517
 518 func.func @group_non_uniform_bitwise_or(%val: i1) -> i1 {
 519   // expected-error @+1 {{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/8/16, but got 'i1'}}
 520   %0 = spirv.GroupNonUniformBitwiseOr <Workgroup> <Reduce> %val : i1 -> i1
 521   return %0: i1
 522 }
 523
 524 // -----
 525
 526 //===----------------------------------------------------------------------===//
 527 // spirv.GroupNonUniformBitwiseXor
 528 //===----------------------------------------------------------------------===//
 529
 530 // CHECK-LABEL: @group_non_uniform_bitwise_xor
 531 func.func @group_non_uniform_bitwise_xor(%val: i32) -> i32 {
 532   // CHECK: %{{.+}} = spirv.GroupNonUniformBitwiseXor <Workgroup> <Reduce> %{{.+}} : i32 -> i32
 533   %0 = spirv.GroupNonUniformBitwiseXor <Workgroup> <Reduce> %val : i32 -> i32
 534   return %0: i32
 535 }
 536
 537 // -----
 538
 539 func.func @group_non_uniform_bitwise_xor(%val: i1) -> i1 {
 540   // expected-error @+1 {{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/8/16, but got 'i1'}}
 541   %0 = spirv.GroupNonUniformBitwiseXor <Workgroup> <Reduce> %val : i1 -> i1
 542   return %0: i1
 543 }
 544
 545 // -----
 546
 547 //===----------------------------------------------------------------------===//
 548 // spirv.GroupNonUniformLogicalAnd
 549 //===----------------------------------------------------------------------===//
 550
 551 // CHECK-LABEL: @group_non_uniform_logical_and
 552 func.func @group_non_uniform_logical_and(%val: i1) -> i1 {
 553   // CHECK: %{{.+}} = spirv.GroupNonUniformLogicalAnd <Workgroup> <Reduce> %{{.+}} : i1 -> i1
 554   %0 = spirv.GroupNonUniformLogicalAnd <Workgroup> <Reduce> %val : i1 -> i1
 555   return %0: i1
 556 }
 557
 558 // -----
 559
 560 func.func @group_non_uniform_logical_and(%val: i32) -> i32 {
 561   // expected-error @+1 {{operand #0 must be bool or vector of bool values of length 2/3/4/8/16, but got 'i32'}}
 562   %0 = spirv.GroupNonUniformLogicalAnd <Workgroup> <Reduce> %val : i32 -> i32
 563   return %0: i32
 564 }
 565
 566 // -----
 567
 568 //===----------------------------------------------------------------------===//
 569 // spirv.GroupNonUniformLogicalOr
 570 //===----------------------------------------------------------------------===//
 571
 572 // CHECK-LABEL: @group_non_uniform_logical_or
 573 func.func @group_non_uniform_logical_or(%val: i1) -> i1 {
 574   // CHECK: %{{.+}} = spirv.GroupNonUniformLogicalOr <Workgroup> <Reduce> %{{.+}} : i1 -> i1
 575   %0 = spirv.GroupNonUniformLogicalOr <Workgroup> <Reduce> %val : i1 -> i1
 576   return %0: i1
 577 }
 578
 579 // -----
 580
 581 func.func @group_non_uniform_logical_or(%val: i32) -> i32 {
 582   // expected-error @+1 {{operand #0 must be bool or vector of bool values of length 2/3/4/8/16, but got 'i32'}}
 583   %0 = spirv.GroupNonUniformLogicalOr <Workgroup> <Reduce> %val : i32 -> i32
 584   return %0: i32
 585 }
 586
 587 // -----
 588
 589 //===----------------------------------------------------------------------===//
 590 // spirv.GroupNonUniformLogicalXor
 591 //===----------------------------------------------------------------------===//
 592
 593 // CHECK-LABEL: @group_non_uniform_logical_xor
 594 func.func @group_non_uniform_logical_xor(%val: i1) -> i1 {
 595   // CHECK: %{{.+}} = spirv.GroupNonUniformLogicalXor <Workgroup> <Reduce> %{{.+}} : i1 -> i1
 596   %0 = spirv.GroupNonUniformLogicalXor <Workgroup> <Reduce> %val : i1 -> i1
 597   return %0: i1
 598 }
 599
 600 // -----
 601
 602 func.func @group_non_uniform_logical_xor(%val: i32) -> i32 {
 603   // expected-error @+1 {{operand #0 must be bool or vector of bool values of length 2/3/4/8/16, but got 'i32'}}
 604   %0 = spirv.GroupNonUniformLogicalXor <Workgroup> <Reduce> %val : i32 -> i32
 605   return %0: i32
 606 }