1// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s 2 3//===----------------------------------------------------------------------===// 4// spirv.IEqual 5//===----------------------------------------------------------------------===// 6 7func.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 15func.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 27func.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 39func.func @isinf_scalar(%arg0: f32) -> i1 { 40 // CHECK: spirv.IsInf {{.*}} : f32 41 %0 = spirv.IsInf %arg0 : f32 42 return %0 : i1 43} 44 45func.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 57func.func @isnan_scalar(%arg0: f32) -> i1 { 58 // CHECK: spirv.IsNan {{.*}} : f32 59 %0 = spirv.IsNan %arg0 : f32 60 return %0 : i1 61} 62 63func.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 73func.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 82func.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 91func.func @logicalBinary(%arg0 : i1, %arg1 : i1) 92{ 93 // expected-error @+1 {{expected ':'}} 94 %0 = spirv.LogicalAnd %arg0, %arg1 95 return 96} 97 98// ----- 99 100func.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 109func.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 122func.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 131func.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 140func.func @logicalUnary(%arg0 : i1) 141{ 142 // expected-error @+1 {{expected ':'}} 143 %0 = spirv.LogicalNot %arg0 144 return 145} 146 147// ----- 148 149func.func @logicalUnary(%arg0 : i1) 150{ 151 // expected-error @+1 {{expected non-function type}} 152 %0 = spirv.LogicalNot %arg0 : 153 return 154} 155 156// ----- 157 158func.func @logicalUnary(%arg0 : i1) 159{ 160 // expected-error @+1 {{expected SSA operand}} 161 %0 = spirv.LogicalNot : i1 162 return 163} 164 165// ----- 166 167func.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 180func.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 188func.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 196func.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 204func.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 212func.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 220func.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 230func.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 240func.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 250func.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 260func.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 270func.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 288func.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 300func.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 312func.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 324func.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 336func.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 348func.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 360func.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 372func.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} 377