403 lines · plain
1// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s2 3//===----------------------------------------------------------------------===//4// spirv.IEqual5//===----------------------------------------------------------------------===//6 7func.func @iequal_scalar(%arg0: i32, %arg1: i32) -> i1 {8 // CHECK: spirv.IEqual {{.*}}, {{.*}} : i329 %0 = spirv.IEqual %arg0, %arg1 : i3210 return %0 : i111}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.INotEqual25//===----------------------------------------------------------------------===//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.IsFinite37//===----------------------------------------------------------------------===//38 39func.func @isfinite_scalar(%arg0: f32) -> i1 {40 // CHECK: spirv.IsFinite {{.*}} : f3241 %0 = spirv.IsFinite %arg0 : f3242 return %0 : i143}44 45func.func @isfinite_vector(%arg0: vector<2xf32>) -> vector<2xi1> {46 // CHECK: spirv.IsFinite {{.*}} : vector<2xf32>47 %0 = spirv.IsFinite %arg0 : vector<2xf32>48 return %0 : vector<2xi1>49}50 51// -----52 53//===----------------------------------------------------------------------===//54// spirv.IsInf55//===----------------------------------------------------------------------===//56 57func.func @isinf_scalar(%arg0: f32) -> i1 {58 // CHECK: spirv.IsInf {{.*}} : f3259 %0 = spirv.IsInf %arg0 : f3260 return %0 : i161}62 63func.func @isinf_vector(%arg0: vector<2xf32>) -> vector<2xi1> {64 // CHECK: spirv.IsInf {{.*}} : vector<2xf32>65 %0 = spirv.IsInf %arg0 : vector<2xf32>66 return %0 : vector<2xi1>67}68 69// -----70 71//===----------------------------------------------------------------------===//72// spirv.IsNan73//===----------------------------------------------------------------------===//74 75func.func @isnan_scalar(%arg0: f32) -> i1 {76 // CHECK: spirv.IsNan {{.*}} : f3277 %0 = spirv.IsNan %arg0 : f3278 return %0 : i179}80 81func.func @isnan_vector(%arg0: vector<2xf32>) -> vector<2xi1> {82 // CHECK: spirv.IsNan {{.*}} : vector<2xf32>83 %0 = spirv.IsNan %arg0 : vector<2xf32>84 return %0 : vector<2xi1>85}86 87//===----------------------------------------------------------------------===//88// spirv.LogicalAnd89//===----------------------------------------------------------------------===//90 91func.func @logicalBinary(%arg0 : i1, %arg1 : i1, %arg2 : i1)92{93 // CHECK: [[TMP:%.*]] = spirv.LogicalAnd {{%.*}}, {{%.*}} : i194 %0 = spirv.LogicalAnd %arg0, %arg1 : i195 // CHECK: {{%.*}} = spirv.LogicalAnd [[TMP]], {{%.*}} : i196 %1 = spirv.LogicalAnd %0, %arg2 : i197 return98}99 100func.func @logicalBinary2(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>)101{102 // CHECK: {{%.*}} = spirv.LogicalAnd {{%.*}}, {{%.*}} : vector<4xi1>103 %0 = spirv.LogicalAnd %arg0, %arg1 : vector<4xi1>104 return105}106 107// -----108 109func.func @logicalBinary(%arg0 : i1, %arg1 : i1)110{111 // expected-error @+1 {{expected ':'}}112 %0 = spirv.LogicalAnd %arg0, %arg1113 return114}115 116// -----117 118func.func @logicalBinary(%arg0 : i1, %arg1 : i1)119{120 // expected-error @+1 {{expected non-function type}}121 %0 = spirv.LogicalAnd %arg0, %arg1 :122 return123}124 125// -----126 127func.func @logicalBinary(%arg0 : i1, %arg1 : i1)128{129 // expected-error @+1 {{expected ','}}130 %0 = spirv.LogicalAnd %arg0 : i1131 return132}133 134// -----135 136//===----------------------------------------------------------------------===//137// spirv.LogicalNot138//===----------------------------------------------------------------------===//139 140func.func @logicalUnary(%arg0 : i1, %arg1 : i1)141{142 // CHECK: [[TMP:%.*]] = spirv.LogicalNot {{%.*}} : i1143 %0 = spirv.LogicalNot %arg0 : i1144 // CHECK: {{%.*}} = spirv.LogicalNot [[TMP]] : i1145 %1 = spirv.LogicalNot %0 : i1146 return147}148 149func.func @logicalUnary2(%arg0 : vector<4xi1>)150{151 // CHECK: {{%.*}} = spirv.LogicalNot {{%.*}} : vector<4xi1>152 %0 = spirv.LogicalNot %arg0 : vector<4xi1>153 return154}155 156// -----157 158func.func @logicalUnary(%arg0 : i1)159{160 // expected-error @+1 {{expected ':'}}161 %0 = spirv.LogicalNot %arg0162 return163}164 165// -----166 167func.func @logicalUnary(%arg0 : i1)168{169 // expected-error @+1 {{expected non-function type}}170 %0 = spirv.LogicalNot %arg0 :171 return172}173 174// -----175 176func.func @logicalUnary(%arg0 : i1)177{178 // expected-error @+1 {{expected SSA operand}}179 %0 = spirv.LogicalNot : i1180 return181}182 183// -----184 185func.func @logicalUnary(%arg0 : i32)186{187 // expected-error @+1 {{'operand' must be bool or fixed-length vector of bool values of length 2/3/4/8/16, but got 'i32'}}188 %0 = spirv.LogicalNot %arg0 : i32189 return190}191 192// -----193 194//===----------------------------------------------------------------------===//195// spirv.SelectOp196//===----------------------------------------------------------------------===//197 198func.func @select_op_bool(%arg0: i1) -> () {199 %0 = spirv.Constant true200 %1 = spirv.Constant false201 // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i1202 %2 = spirv.Select %arg0, %0, %1 : i1, i1203 return204}205 206func.func @select_op_int(%arg0: i1) -> () {207 %0 = spirv.Constant 2 : i32208 %1 = spirv.Constant 3 : i32209 // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i32210 %2 = spirv.Select %arg0, %0, %1 : i1, i32211 return212}213 214func.func @select_op_float(%arg0: i1) -> () {215 %0 = spirv.Constant 2.0 : f32216 %1 = spirv.Constant 3.0 : f32217 // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, f32218 %2 = spirv.Select %arg0, %0, %1 : i1, f32219 return220}221 222func.func @select_op_bfloat16(%arg0: i1) -> () {223 %0 = spirv.Constant 2.0 : bf16224 %1 = spirv.Constant 3.0 : bf16225 // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, bf16226 %2 = spirv.Select %arg0, %0, %1 : i1, bf16227 return228}229 230func.func @select_op_ptr(%arg0: i1) -> () {231 %0 = spirv.Variable : !spirv.ptr<f32, Function>232 %1 = spirv.Variable : !spirv.ptr<f32, Function>233 // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, !spirv.ptr<f32, Function>234 %2 = spirv.Select %arg0, %0, %1 : i1, !spirv.ptr<f32, Function>235 return236}237 238func.func @select_op_vec(%arg0: i1) -> () {239 %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>240 %1 = spirv.Constant dense<[5.0, 6.0, 7.0]> : vector<3xf32>241 // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, vector<3xf32>242 %2 = spirv.Select %arg0, %0, %1 : i1, vector<3xf32>243 return244}245 246func.func @select_op_vec_condn_vec(%arg0: vector<3xi1>) -> () {247 %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>248 %1 = spirv.Constant dense<[5.0, 6.0, 7.0]> : vector<3xf32>249 // CHECK: spirv.Select {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi1>, vector<3xf32>250 %2 = spirv.Select %arg0, %0, %1 : vector<3xi1>, vector<3xf32>251 return252}253 254// -----255 256func.func @select_op(%arg0: i1) -> () {257 %0 = spirv.Constant 2 : i32258 %1 = spirv.Constant 3 : i32259 // expected-error @+1 {{expected ','}}260 %2 = spirv.Select %arg0, %0, %1 : i1261 return262}263 264// -----265 266func.func @select_op(%arg1: vector<3xi1>) -> () {267 %0 = spirv.Constant 2 : i32268 %1 = spirv.Constant 3 : i32269 // expected-error @+1 {{result expected to be of vector type when condition is of vector type}}270 %2 = spirv.Select %arg1, %0, %1 : vector<3xi1>, i32271 return272}273 274// -----275 276func.func @select_op(%arg1: vector<4xi1>) -> () {277 %0 = spirv.Constant dense<[2, 3, 4]> : vector<3xi32>278 %1 = spirv.Constant dense<[5, 6, 7]> : vector<3xi32>279 // expected-error @+1 {{result should have the same number of elements as the condition when condition is of vector type}}280 %2 = spirv.Select %arg1, %0, %1 : vector<4xi1>, vector<3xi32>281 return282}283 284// -----285 286func.func @select_op(%arg1: vector<4xi1>) -> () {287 %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>288 %1 = spirv.Constant dense<[5, 6, 7]> : vector<3xi32>289 // expected-error @+1 {{all of {true_value, false_value, result} have same type}}290 %2 = "spirv.Select"(%arg1, %0, %1) : (vector<4xi1>, vector<3xf32>, vector<3xi32>) -> vector<3xi32>291 return292}293 294// -----295 296func.func @select_op(%arg1: vector<4xi1>) -> () {297 %0 = spirv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>298 %1 = spirv.Constant dense<[5, 6, 7]> : vector<3xi32>299 // TODO: expand post change in verification order. This is currently only300 // verifying that the type verification is failing but not the specific error301 // message. In final state the error should refer to mismatch in true_value and302 // false_value.303 // expected-error @+1 {{type}}304 %2 = "spirv.Select"(%arg1, %1, %0) : (vector<4xi1>, vector<3xi32>, vector<3xf32>) -> vector<3xi32>305 return306}307 308// -----309 310//===----------------------------------------------------------------------===//311// spirv.SGreaterThan312//===----------------------------------------------------------------------===//313 314func.func @sgt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {315 // CHECK: spirv.SGreaterThan {{.*}}, {{.*}} : vector<4xi32>316 %0 = spirv.SGreaterThan %arg0, %arg1 : vector<4xi32>317 return %0 : vector<4xi1>318}319 320// -----321 322//===----------------------------------------------------------------------===//323// spirv.SGreaterThanEqual324//===----------------------------------------------------------------------===//325 326func.func @sge_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {327 // CHECK: spirv.SGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>328 %0 = spirv.SGreaterThanEqual %arg0, %arg1 : vector<4xi32>329 return %0 : vector<4xi1>330}331 332// -----333 334//===----------------------------------------------------------------------===//335// spirv.SLessThan336//===----------------------------------------------------------------------===//337 338func.func @slt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {339 // CHECK: spirv.SLessThan {{.*}}, {{.*}} : vector<4xi32>340 %0 = spirv.SLessThan %arg0, %arg1 : vector<4xi32>341 return %0 : vector<4xi1>342}343 344// -----345 346//===----------------------------------------------------------------------===//347// spirv.SLessThanEqual348//===----------------------------------------------------------------------===//349 350func.func @slte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {351 // CHECK: spirv.SLessThanEqual {{.*}}, {{.*}} : vector<4xi32>352 %0 = spirv.SLessThanEqual %arg0, %arg1 : vector<4xi32>353 return %0 : vector<4xi1>354}355 356// -----357 358//===----------------------------------------------------------------------===//359// spirv.UGreaterThan360//===----------------------------------------------------------------------===//361 362func.func @ugt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {363 // CHECK: spirv.UGreaterThan {{.*}}, {{.*}} : vector<4xi32>364 %0 = spirv.UGreaterThan %arg0, %arg1 : vector<4xi32>365 return %0 : vector<4xi1>366}367 368// -----369 370//===----------------------------------------------------------------------===//371// spirv.UGreaterThanEqual372//===----------------------------------------------------------------------===//373 374func.func @ugte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {375 // CHECK: spirv.UGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>376 %0 = spirv.UGreaterThanEqual %arg0, %arg1 : vector<4xi32>377 return %0 : vector<4xi1>378}379 380// -----381 382//===----------------------------------------------------------------------===//383// spirv.ULessThan384//===----------------------------------------------------------------------===//385 386func.func @ult_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {387 // CHECK: spirv.ULessThan {{.*}}, {{.*}} : vector<4xi32>388 %0 = spirv.ULessThan %arg0, %arg1 : vector<4xi32>389 return %0 : vector<4xi1>390}391 392// -----393 394//===----------------------------------------------------------------------===//395// spirv.ULessThanEqual396//===----------------------------------------------------------------------===//397 398func.func @ulte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {399 // CHECK: spirv.ULessThanEqual {{.*}}, {{.*}} : vector<4xi32>400 %0 = spirv.ULessThanEqual %arg0, %arg1 : vector<4xi32>401 return %0 : vector<4xi1>402}403