1// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s 2 3//===----------------------------------------------------------------------===// 4// spv.IEqual 5//===----------------------------------------------------------------------===// 6 7// CHECK-LABEL: @i_equal_scalar 8spv.func @i_equal_scalar(%arg0: i32, %arg1: i32) "None" { 9 // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : i32 10 %0 = spv.IEqual %arg0, %arg1 : i32 11 spv.Return 12} 13 14// CHECK-LABEL: @i_equal_vector 15spv.func @i_equal_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" { 16 // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : vector<4xi64> 17 %0 = spv.IEqual %arg0, %arg1 : vector<4xi64> 18 spv.Return 19} 20 21//===----------------------------------------------------------------------===// 22// spv.INotEqual 23//===----------------------------------------------------------------------===// 24 25// CHECK-LABEL: @i_not_equal_scalar 26spv.func @i_not_equal_scalar(%arg0: i64, %arg1: i64) "None" { 27 // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : i64 28 %0 = spv.INotEqual %arg0, %arg1 : i64 29 spv.Return 30} 31 32// CHECK-LABEL: @i_not_equal_vector 33spv.func @i_not_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 34 // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : vector<2xi64> 35 %0 = spv.INotEqual %arg0, %arg1 : vector<2xi64> 36 spv.Return 37} 38 39//===----------------------------------------------------------------------===// 40// spv.SGreaterThanEqual 41//===----------------------------------------------------------------------===// 42 43// CHECK-LABEL: @s_greater_than_equal_scalar 44spv.func @s_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { 45 // CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : i64 46 %0 = spv.SGreaterThanEqual %arg0, %arg1 : i64 47 spv.Return 48} 49 50// CHECK-LABEL: @s_greater_than_equal_vector 51spv.func @s_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 52 // CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : vector<2xi64> 53 %0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<2xi64> 54 spv.Return 55} 56 57//===----------------------------------------------------------------------===// 58// spv.SGreaterThan 59//===----------------------------------------------------------------------===// 60 61// CHECK-LABEL: @s_greater_than_scalar 62spv.func @s_greater_than_scalar(%arg0: i64, %arg1: i64) "None" { 63 // CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : i64 64 %0 = spv.SGreaterThan %arg0, %arg1 : i64 65 spv.Return 66} 67 68// CHECK-LABEL: @s_greater_than_vector 69spv.func @s_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 70 // CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : vector<2xi64> 71 %0 = spv.SGreaterThan %arg0, %arg1 : vector<2xi64> 72 spv.Return 73} 74 75//===----------------------------------------------------------------------===// 76// spv.SLessThanEqual 77//===----------------------------------------------------------------------===// 78 79// CHECK-LABEL: @s_less_than_equal_scalar 80spv.func @s_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { 81 // CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : i64 82 %0 = spv.SLessThanEqual %arg0, %arg1 : i64 83 spv.Return 84} 85 86// CHECK-LABEL: @s_less_than_equal_vector 87spv.func @s_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 88 // CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : vector<2xi64> 89 %0 = spv.SLessThanEqual %arg0, %arg1 : vector<2xi64> 90 spv.Return 91} 92 93//===----------------------------------------------------------------------===// 94// spv.SLessThan 95//===----------------------------------------------------------------------===// 96 97// CHECK-LABEL: @s_less_than_scalar 98spv.func @s_less_than_scalar(%arg0: i64, %arg1: i64) "None" { 99 // CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : i64 100 %0 = spv.SLessThan %arg0, %arg1 : i64 101 spv.Return 102} 103 104// CHECK-LABEL: @s_less_than_vector 105spv.func @s_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 106 // CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : vector<2xi64> 107 %0 = spv.SLessThan %arg0, %arg1 : vector<2xi64> 108 spv.Return 109} 110 111//===----------------------------------------------------------------------===// 112// spv.UGreaterThanEqual 113//===----------------------------------------------------------------------===// 114 115// CHECK-LABEL: @u_greater_than_equal_scalar 116spv.func @u_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { 117 // CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : i64 118 %0 = spv.UGreaterThanEqual %arg0, %arg1 : i64 119 spv.Return 120} 121 122// CHECK-LABEL: @u_greater_than_equal_vector 123spv.func @u_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 124 // CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : vector<2xi64> 125 %0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<2xi64> 126 spv.Return 127} 128 129//===----------------------------------------------------------------------===// 130// spv.UGreaterThan 131//===----------------------------------------------------------------------===// 132 133// CHECK-LABEL: @u_greater_than_scalar 134spv.func @u_greater_than_scalar(%arg0: i64, %arg1: i64) "None" { 135 // CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : i64 136 %0 = spv.UGreaterThan %arg0, %arg1 : i64 137 spv.Return 138} 139 140// CHECK-LABEL: @u_greater_than_vector 141spv.func @u_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 142 // CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : vector<2xi64> 143 %0 = spv.UGreaterThan %arg0, %arg1 : vector<2xi64> 144 spv.Return 145} 146 147//===----------------------------------------------------------------------===// 148// spv.ULessThanEqual 149//===----------------------------------------------------------------------===// 150 151// CHECK-LABEL: @u_less_than_equal_scalar 152spv.func @u_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { 153 // CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : i64 154 %0 = spv.ULessThanEqual %arg0, %arg1 : i64 155 spv.Return 156} 157 158// CHECK-LABEL: @u_less_than_equal_vector 159spv.func @u_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 160 // CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : vector<2xi64> 161 %0 = spv.ULessThanEqual %arg0, %arg1 : vector<2xi64> 162 spv.Return 163} 164 165//===----------------------------------------------------------------------===// 166// spv.ULessThan 167//===----------------------------------------------------------------------===// 168 169// CHECK-LABEL: @u_less_than_scalar 170spv.func @u_less_than_scalar(%arg0: i64, %arg1: i64) "None" { 171 // CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : i64 172 %0 = spv.ULessThan %arg0, %arg1 : i64 173 spv.Return 174} 175 176// CHECK-LABEL: @u_less_than_vector 177spv.func @u_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { 178 // CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : vector<2xi64> 179 %0 = spv.ULessThan %arg0, %arg1 : vector<2xi64> 180 spv.Return 181} 182 183//===----------------------------------------------------------------------===// 184// spv.FOrdEqual 185//===----------------------------------------------------------------------===// 186 187// CHECK-LABEL: @f_ord_equal_scalar 188spv.func @f_ord_equal_scalar(%arg0: f32, %arg1: f32) "None" { 189 // CHECK: llvm.fcmp "oeq" %{{.*}}, %{{.*}} : f32 190 %0 = spv.FOrdEqual %arg0, %arg1 : f32 191 spv.Return 192} 193 194// CHECK-LABEL: @f_ord_equal_vector 195spv.func @f_ord_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" { 196 // CHECK: llvm.fcmp "oeq" %{{.*}}, %{{.*}} : vector<4xf64> 197 %0 = spv.FOrdEqual %arg0, %arg1 : vector<4xf64> 198 spv.Return 199} 200 201//===----------------------------------------------------------------------===// 202// spv.FOrdGreaterThanEqual 203//===----------------------------------------------------------------------===// 204 205// CHECK-LABEL: @f_ord_greater_than_equal_scalar 206spv.func @f_ord_greater_than_equal_scalar(%arg0: f64, %arg1: f64) "None" { 207 // CHECK: llvm.fcmp "oge" %{{.*}}, %{{.*}} : f64 208 %0 = spv.FOrdGreaterThanEqual %arg0, %arg1 : f64 209 spv.Return 210} 211 212// CHECK-LABEL: @f_ord_greater_than_equal_vector 213spv.func @f_ord_greater_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 214 // CHECK: llvm.fcmp "oge" %{{.*}}, %{{.*}} : vector<2xf64> 215 %0 = spv.FOrdGreaterThanEqual %arg0, %arg1 : vector<2xf64> 216 spv.Return 217} 218 219//===----------------------------------------------------------------------===// 220// spv.FOrdGreaterThan 221//===----------------------------------------------------------------------===// 222 223// CHECK-LABEL: @f_ord_greater_than_scalar 224spv.func @f_ord_greater_than_scalar(%arg0: f64, %arg1: f64) "None" { 225 // CHECK: llvm.fcmp "ogt" %{{.*}}, %{{.*}} : f64 226 %0 = spv.FOrdGreaterThan %arg0, %arg1 : f64 227 spv.Return 228} 229 230// CHECK-LABEL: @f_ord_greater_than_vector 231spv.func @f_ord_greater_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 232 // CHECK: llvm.fcmp "ogt" %{{.*}}, %{{.*}} : vector<2xf64> 233 %0 = spv.FOrdGreaterThan %arg0, %arg1 : vector<2xf64> 234 spv.Return 235} 236 237//===----------------------------------------------------------------------===// 238// spv.FOrdLessThan 239//===----------------------------------------------------------------------===// 240 241// CHECK-LABEL: @f_ord_less_than_scalar 242spv.func @f_ord_less_than_scalar(%arg0: f64, %arg1: f64) "None" { 243 // CHECK: llvm.fcmp "olt" %{{.*}}, %{{.*}} : f64 244 %0 = spv.FOrdLessThan %arg0, %arg1 : f64 245 spv.Return 246} 247 248// CHECK-LABEL: @f_ord_less_than_vector 249spv.func @f_ord_less_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 250 // CHECK: llvm.fcmp "olt" %{{.*}}, %{{.*}} : vector<2xf64> 251 %0 = spv.FOrdLessThan %arg0, %arg1 : vector<2xf64> 252 spv.Return 253} 254 255//===----------------------------------------------------------------------===// 256// spv.FOrdLessThanEqual 257//===----------------------------------------------------------------------===// 258 259// CHECK-LABEL: @f_ord_less_than_equal_scalar 260spv.func @f_ord_less_than_equal_scalar(%arg0: f64, %arg1: f64) "None" { 261 // CHECK: llvm.fcmp "ole" %{{.*}}, %{{.*}} : f64 262 %0 = spv.FOrdLessThanEqual %arg0, %arg1 : f64 263 spv.Return 264} 265 266// CHECK-LABEL: @f_ord_less_than_equal_vector 267spv.func @f_ord_less_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 268 // CHECK: llvm.fcmp "ole" %{{.*}}, %{{.*}} : vector<2xf64> 269 %0 = spv.FOrdLessThanEqual %arg0, %arg1 : vector<2xf64> 270 spv.Return 271} 272 273//===----------------------------------------------------------------------===// 274// spv.FOrdNotEqual 275//===----------------------------------------------------------------------===// 276 277// CHECK-LABEL: @f_ord_not_equal_scalar 278spv.func @f_ord_not_equal_scalar(%arg0: f32, %arg1: f32) "None" { 279 // CHECK: llvm.fcmp "one" %{{.*}}, %{{.*}} : f32 280 %0 = spv.FOrdNotEqual %arg0, %arg1 : f32 281 spv.Return 282} 283 284// CHECK-LABEL: @f_ord_not_equal_vector 285spv.func @f_ord_not_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" { 286 // CHECK: llvm.fcmp "one" %{{.*}}, %{{.*}} : vector<4xf64> 287 %0 = spv.FOrdNotEqual %arg0, %arg1 : vector<4xf64> 288 spv.Return 289} 290 291//===----------------------------------------------------------------------===// 292// spv.FUnordEqual 293//===----------------------------------------------------------------------===// 294 295// CHECK-LABEL: @f_unord_equal_scalar 296spv.func @f_unord_equal_scalar(%arg0: f32, %arg1: f32) "None" { 297 // CHECK: llvm.fcmp "ueq" %{{.*}}, %{{.*}} : f32 298 %0 = spv.FUnordEqual %arg0, %arg1 : f32 299 spv.Return 300} 301 302// CHECK-LABEL: @f_unord_equal_vector 303spv.func @f_unord_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" { 304 // CHECK: llvm.fcmp "ueq" %{{.*}}, %{{.*}} : vector<4xf64> 305 %0 = spv.FUnordEqual %arg0, %arg1 : vector<4xf64> 306 spv.Return 307} 308 309//===----------------------------------------------------------------------===// 310// spv.FUnordGreaterThanEqual 311//===----------------------------------------------------------------------===// 312 313// CHECK-LABEL: @f_unord_greater_than_equal_scalar 314spv.func @f_unord_greater_than_equal_scalar(%arg0: f64, %arg1: f64) "None" { 315 // CHECK: llvm.fcmp "uge" %{{.*}}, %{{.*}} : f64 316 %0 = spv.FUnordGreaterThanEqual %arg0, %arg1 : f64 317 spv.Return 318} 319 320// CHECK-LABEL: @f_unord_greater_than_equal_vector 321spv.func @f_unord_greater_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 322 // CHECK: llvm.fcmp "uge" %{{.*}}, %{{.*}} : vector<2xf64> 323 %0 = spv.FUnordGreaterThanEqual %arg0, %arg1 : vector<2xf64> 324 spv.Return 325} 326 327//===----------------------------------------------------------------------===// 328// spv.FUnordGreaterThan 329//===----------------------------------------------------------------------===// 330 331// CHECK-LABEL: @f_unord_greater_than_scalar 332spv.func @f_unord_greater_than_scalar(%arg0: f64, %arg1: f64) "None" { 333 // CHECK: llvm.fcmp "ugt" %{{.*}}, %{{.*}} : f64 334 %0 = spv.FUnordGreaterThan %arg0, %arg1 : f64 335 spv.Return 336} 337 338// CHECK-LABEL: @f_unord_greater_than_vector 339spv.func @f_unord_greater_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 340 // CHECK: llvm.fcmp "ugt" %{{.*}}, %{{.*}} : vector<2xf64> 341 %0 = spv.FUnordGreaterThan %arg0, %arg1 : vector<2xf64> 342 spv.Return 343} 344 345//===----------------------------------------------------------------------===// 346// spv.FUnordLessThan 347//===----------------------------------------------------------------------===// 348 349// CHECK-LABEL: @f_unord_less_than_scalar 350spv.func @f_unord_less_than_scalar(%arg0: f64, %arg1: f64) "None" { 351 // CHECK: llvm.fcmp "ult" %{{.*}}, %{{.*}} : f64 352 %0 = spv.FUnordLessThan %arg0, %arg1 : f64 353 spv.Return 354} 355 356// CHECK-LABEL: @f_unord_less_than_vector 357spv.func @f_unord_less_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 358 // CHECK: llvm.fcmp "ult" %{{.*}}, %{{.*}} : vector<2xf64> 359 %0 = spv.FUnordLessThan %arg0, %arg1 : vector<2xf64> 360 spv.Return 361} 362 363//===----------------------------------------------------------------------===// 364// spv.FUnordLessThanEqual 365//===----------------------------------------------------------------------===// 366 367// CHECK-LABEL: @f_unord_less_than_equal_scalar 368spv.func @f_unord_less_than_equal_scalar(%arg0: f64, %arg1: f64) "None" { 369 // CHECK: llvm.fcmp "ule" %{{.*}}, %{{.*}} : f64 370 %0 = spv.FUnordLessThanEqual %arg0, %arg1 : f64 371 spv.Return 372} 373 374// CHECK-LABEL: @f_unord_less_than_equal_vector 375spv.func @f_unord_less_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" { 376 // CHECK: llvm.fcmp "ule" %{{.*}}, %{{.*}} : vector<2xf64> 377 %0 = spv.FUnordLessThanEqual %arg0, %arg1 : vector<2xf64> 378 spv.Return 379} 380 381//===----------------------------------------------------------------------===// 382// spv.FUnordNotEqual 383//===----------------------------------------------------------------------===// 384 385// CHECK-LABEL: @f_unord_not_equal_scalar 386spv.func @f_unord_not_equal_scalar(%arg0: f32, %arg1: f32) "None" { 387 // CHECK: llvm.fcmp "une" %{{.*}}, %{{.*}} : f32 388 %0 = spv.FUnordNotEqual %arg0, %arg1 : f32 389 spv.Return 390} 391 392// CHECK-LABEL: @f_unord_not_equal_vector 393spv.func @f_unord_not_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" { 394 // CHECK: llvm.fcmp "une" %{{.*}}, %{{.*}} : vector<4xf64> 395 %0 = spv.FUnordNotEqual %arg0, %arg1 : vector<4xf64> 396 spv.Return 397} 398