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

   1 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
   2
   3 //===----------------------------------------------------------------------===//
   4 // spirv.IEqual
   5 //===----------------------------------------------------------------------===//
   6
   7 func.func @iequal_scalar(%arg0: i32, %arg1: i32) -> i1 {
   8   // CHECK: spirv.IEqual {{.*}}, {{.*}} : i32
   9   %0 = spirv.IEqual %arg0, %arg1 : i32
  10   return %0 : i1
  11 }
  12
  13 // -----
  14
  15 func.func @iequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
  16   // CHECK: spirv.IEqual {{.*}}, {{.*}} : vector<4xi32>
  17   %0 = spirv.IEqual %arg0, %arg1 : vector<4xi32>
  18   return %0 : vector<4xi1>
  19 }
  20
  21 // -----
  22
  23 //===----------------------------------------------------------------------===//
  24 // spirv.INotEqual
  25 //===----------------------------------------------------------------------===//
  26
  27 func.func @inotequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
  28   // CHECK: spirv.INotEqual {{.*}}, {{.*}} : vector<4xi32>
  29   %0 = spirv.INotEqual %arg0, %arg1 : vector<4xi32>
  30   return %0 : vector<4xi1>
  31 }
  32
  33 // -----
  34
  35 //===----------------------------------------------------------------------===//
  36 // spirv.IsInf
  37 //===----------------------------------------------------------------------===//
  38
  39 func.func @isinf_scalar(%arg0: f32) -> i1 {
  40   // CHECK: spirv.IsInf {{.*}} : f32
  41   %0 = spirv.IsInf %arg0 : f32
  42   return %0 : i1
  43 }
  44
  45 func.func @isinf_vector(%arg0: vector<2xf32>) -> vector<2xi1> {
  46   // CHECK: spirv.IsInf {{.*}} : vector<2xf32>
  47   %0 = spirv.IsInf %arg0 : vector<2xf32>
  48   return %0 : vector<2xi1>
  49 }
  50
  51 // -----
  52
  53 //===----------------------------------------------------------------------===//
  54 // spirv.IsNan
  55 //===----------------------------------------------------------------------===//
  56
  57 func.func @isnan_scalar(%arg0: f32) -> i1 {
  58   // CHECK: spirv.IsNan {{.*}} : f32
  59   %0 = spirv.IsNan %arg0 : f32
  60   return %0 : i1
  61 }
  62
  63 func.func @isnan_vector(%arg0: vector<2xf32>) -> vector<2xi1> {
  64   // CHECK: spirv.IsNan {{.*}} : vector<2xf32>
  65   %0 = spirv.IsNan %arg0 : vector<2xf32>
  66   return %0 : vector<2xi1>
  67 }
  68
  69 //===----------------------------------------------------------------------===//
  70 // spirv.LogicalAnd
  71 //===----------------------------------------------------------------------===//
  72
  73 func.func @logicalBinary(%arg0 : i1, %arg1 : i1, %arg2 : i1)
  74 {
  75   // CHECK: [[TMP:%.*]] = spirv.LogicalAnd {{%.*}}, {{%.*}} : i1
  76   %0 = spirv.LogicalAnd %arg0, %arg1 : i1
  77   // CHECK: {{%.*}} = spirv.LogicalAnd [[TMP]], {{%.*}} : i1
  78   %1 = spirv.LogicalAnd %0, %arg2 : i1
  79   return
  80 }
  81
  82 func.func @logicalBinary2(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>)
  83 {
  84   // CHECK: {{%.*}} = spirv.LogicalAnd {{%.*}}, {{%.*}} : vector<4xi1>
  85   %0 = spirv.LogicalAnd %arg0, %arg1 : vector<4xi1>
  86   return
  87 }
  88
  89 // -----
  90
  91 func.func @logicalBinary(%arg0 : i1, %arg1 : i1)
  92 {
  93   // expected-error @+1 {{expected ':'}}
  94   %0 = spirv.LogicalAnd %arg0, %arg1
  95   return
  96 }
  97
  98 // -----
  99
 100 func.func @logicalBinary(%arg0 : i1, %arg1 : i1)
 101 {
 102   // expected-error @+1 {{expected non-function type}}
 103   %0 = spirv.LogicalAnd %arg0, %arg1 :
 104   return
 105 }
 106
 107 // -----
 108
 109 func.func @logicalBinary(%arg0 : i1, %arg1 : i1)
 110 {
 111   // expected-error @+1 {{expected ','}}
 112   %0 = spirv.LogicalAnd %arg0 : i1
 113   return
 114 }
 115
 116 // -----
 117
 118 //===----------------------------------------------------------------------===//
 119 // spirv.LogicalNot
 120 //===----------------------------------------------------------------------===//
 121
 122 func.func @logicalUnary(%arg0 : i1, %arg1 : i1)
 123 {
 124   // CHECK: [[TMP:%.*]] = spirv.LogicalNot {{%.*}} : i1
 125   %0 = spirv.LogicalNot %arg0 : i1
 126   // CHECK: {{%.*}} = spirv.LogicalNot [[TMP]] : i1
 127   %1 = spirv.LogicalNot %0 : i1
 128   return
 129 }
 130
 131 func.func @logicalUnary2(%arg0 : vector<4xi1>)
 132 {
 133   // CHECK: {{%.*}} = spirv.LogicalNot {{%.*}} : vector<4xi1>
 134   %0 = spirv.LogicalNot %arg0 : vector<4xi1>
 135   return
 136 }
 137
 138 // -----
 139
 140 func.func @logicalUnary(%arg0 : i1)
 141 {
 142   // expected-error @+1 {{expected ':'}}
 143   %0 = spirv.LogicalNot %arg0
 144   return
 145 }
 146
 147 // -----
 148
 149 func.func @logicalUnary(%arg0 : i1)
 150 {
 151   // expected-error @+1 {{expected non-function type}}
 152   %0 = spirv.LogicalNot %arg0 :
 153   return
 154 }
 155
 156 // -----
 157
 158 func.func @logicalUnary(%arg0 : i1)
 159 {
 160   // expected-error @+1 {{expected SSA operand}}
 161   %0 = spirv.LogicalNot : i1
 162   return
 163 }
 164
 165 // -----
 166
 167 func.func @logicalUnary(%arg0 : i32)
 168 {
 169   // expected-error @+1 {{'operand' must be bool or vector of bool values of length 2/3/4/8/16, but got 'i32'}}
 170   %0 = spirv.LogicalNot %arg0 : i32
 171   return
 172 }
 173
 174 // -----
 175
 176 //===----------------------------------------------------------------------===//
 177 // spirv.SelectOp
 178 //===----------------------------------------------------------------------===//
 179
 180 func.func @select_op_bool(%arg0: i1) -> () {
 181   %0 = spirv.Constant true
 182   %1 = spirv.Constant false
 183   // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i1
 184   %2 = spirv.Select %arg0, %0, %1 : i1, i1
 185   return
 186 }
 187
 188 func.func @select_op_int(%arg0: i1) -> () {
 189   %0 = spirv.Constant 2 : i32
 190   %1 = spirv.Constant 3 : i32
 191   // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i32
 192   %2 = spirv.Select %arg0, %0, %1 : i1, i32
 193   return
 194 }
 195
 196 func.func @select_op_float(%arg0: i1) -> () {
 197   %0 = spirv.Constant 2.0 : f32
 198   %1 = spirv.Constant 3.0 : f32
 199   // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, f32
 200   %2 = spirv.Select %arg0, %0, %1 : i1, f32
 201   return
 202 }
 203
 204 func.func @select_op_ptr(%arg0: i1) -> () {
 205   %0 = spirv.Variable : !spirv.ptr<f32, Function>
 206   %1 = spirv.Variable : !spirv.ptr<f32, Function>
 207   // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, !spirv.ptr<f32, Function>
 208   %2 = spirv.Select %arg0, %0, %1 : i1, !spirv.ptr<f32, Function>
 209   return
 210 }
 211
 212 func.func @select_op_vec(%arg0: i1) -> () {
 213   %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
 214   %1 = spirv.Constant dense<[5.0, 6.0, 7.0]> : vector<3xf32>
 215   // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, vector<3xf32>
 216   %2 = spirv.Select %arg0, %0, %1 : i1, vector<3xf32>
 217   return
 218 }
 219
 220 func.func @select_op_vec_condn_vec(%arg0: vector<3xi1>) -> () {
 221   %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
 222   %1 = spirv.Constant dense<[5.0, 6.0, 7.0]> : vector<3xf32>
 223   // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi1>, vector<3xf32>
 224   %2 = spirv.Select %arg0, %0, %1 : vector<3xi1>, vector<3xf32>
 225   return
 226 }
 227
 228 // -----
 229
 230 func.func @select_op(%arg0: i1) -> () {
 231   %0 = spirv.Constant 2 : i32
 232   %1 = spirv.Constant 3 : i32
 233   // expected-error @+1 {{expected ','}}
 234   %2 = spirv.Select %arg0, %0, %1 : i1
 235   return
 236 }
 237
 238 // -----
 239
 240 func.func @select_op(%arg1: vector<3xi1>) -> () {
 241   %0 = spirv.Constant 2 : i32
 242   %1 = spirv.Constant 3 : i32
 243   // expected-error @+1 {{result expected to be of vector type when condition is of vector type}}
 244   %2 = spirv.Select %arg1, %0, %1 : vector<3xi1>, i32
 245   return
 246 }
 247
 248 // -----
 249
 250 func.func @select_op(%arg1: vector<4xi1>) -> () {
 251   %0 = spirv.Constant dense<[2, 3, 4]> : vector<3xi32>
 252   %1 = spirv.Constant dense<[5, 6, 7]> : vector<3xi32>
 253   // expected-error @+1 {{result should have the same number of elements as the condition when condition is of vector type}}
 254   %2 = spirv.Select %arg1, %0, %1 : vector<4xi1>, vector<3xi32>
 255   return
 256 }
 257
 258 // -----
 259
 260 func.func @select_op(%arg1: vector<4xi1>) -> () {
 261   %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
 262   %1 = spirv.Constant dense<[5, 6, 7]> : vector<3xi32>
 263   // expected-error @+1 {{all of {true_value, false_value, result} have same type}}
 264   %2 = "spirv.Select"(%arg1, %0, %1) : (vector<4xi1>, vector<3xf32>, vector<3xi32>) -> vector<3xi32>
 265   return
 266 }
 267
 268 // -----
 269
 270 func.func @select_op(%arg1: vector<4xi1>) -> () {
 271   %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
 272   %1 = spirv.Constant dense<[5, 6, 7]> : vector<3xi32>
 273   // TODO: expand post change in verification order. This is currently only
 274   // verifying that the type verification is failing but not the specific error
 275   // message. In final state the error should refer to mismatch in true_value and
 276   // false_value.
 277   // expected-error @+1 {{type}}
 278   %2 = "spirv.Select"(%arg1, %1, %0) : (vector<4xi1>, vector<3xi32>, vector<3xf32>) -> vector<3xi32>
 279   return
 280 }
 281
 282 // -----
 283
 284 //===----------------------------------------------------------------------===//
 285 // spirv.SGreaterThan
 286 //===----------------------------------------------------------------------===//
 287
 288 func.func @sgt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 289   // CHECK: spirv.SGreaterThan {{.*}}, {{.*}} : vector<4xi32>
 290   %0 = spirv.SGreaterThan %arg0, %arg1 : vector<4xi32>
 291   return %0 : vector<4xi1>
 292 }
 293
 294 // -----
 295
 296 //===----------------------------------------------------------------------===//
 297 // spirv.SGreaterThanEqual
 298 //===----------------------------------------------------------------------===//
 299
 300 func.func @sge_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 301   // CHECK: spirv.SGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>
 302   %0 = spirv.SGreaterThanEqual %arg0, %arg1 : vector<4xi32>
 303   return %0 : vector<4xi1>
 304 }
 305
 306 // -----
 307
 308 //===----------------------------------------------------------------------===//
 309 // spirv.SLessThan
 310 //===----------------------------------------------------------------------===//
 311
 312 func.func @slt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 313   // CHECK: spirv.SLessThan {{.*}}, {{.*}} : vector<4xi32>
 314   %0 = spirv.SLessThan %arg0, %arg1 : vector<4xi32>
 315   return %0 : vector<4xi1>
 316 }
 317
 318 // -----
 319
 320 //===----------------------------------------------------------------------===//
 321 // spirv.SLessThanEqual
 322 //===----------------------------------------------------------------------===//
 323
 324 func.func @slte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 325   // CHECK: spirv.SLessThanEqual {{.*}}, {{.*}} : vector<4xi32>
 326   %0 = spirv.SLessThanEqual %arg0, %arg1 : vector<4xi32>
 327   return %0 : vector<4xi1>
 328 }
 329
 330 // -----
 331
 332 //===----------------------------------------------------------------------===//
 333 // spirv.UGreaterThan
 334 //===----------------------------------------------------------------------===//
 335
 336 func.func @ugt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 337   // CHECK: spirv.UGreaterThan {{.*}}, {{.*}} : vector<4xi32>
 338   %0 = spirv.UGreaterThan %arg0, %arg1 : vector<4xi32>
 339   return %0 : vector<4xi1>
 340 }
 341
 342 // -----
 343
 344 //===----------------------------------------------------------------------===//
 345 // spirv.UGreaterThanEqual
 346 //===----------------------------------------------------------------------===//
 347
 348 func.func @ugte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 349   // CHECK: spirv.UGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>
 350   %0 = spirv.UGreaterThanEqual %arg0, %arg1 : vector<4xi32>
 351   return %0 : vector<4xi1>
 352 }
 353
 354 // -----
 355
 356 //===----------------------------------------------------------------------===//
 357 // spirv.ULessThan
 358 //===----------------------------------------------------------------------===//
 359
 360 func.func @ult_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 361   // CHECK: spirv.ULessThan {{.*}}, {{.*}} : vector<4xi32>
 362   %0 = spirv.ULessThan %arg0, %arg1 : vector<4xi32>
 363   return %0 : vector<4xi1>
 364 }
 365
 366 // -----
 367
 368 //===----------------------------------------------------------------------===//
 369 // spirv.ULessThanEqual
 370 //===----------------------------------------------------------------------===//
 371
 372 func.func @ulte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
 373   // CHECK: spirv.ULessThanEqual {{.*}}, {{.*}} : vector<4xi32>
 374   %0 = spirv.ULessThanEqual %arg0, %arg1 : vector<4xi32>
 375   return %0 : vector<4xi1>
 376 }