1// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s 2 3//===----------------------------------------------------------------------===// 4// spirv.GL.Exp 5//===----------------------------------------------------------------------===// 6 7func.func @exp(%arg0 : f32) -> () { 8 // CHECK: spirv.GL.Exp {{%.*}} : f32 9 %2 = spirv.GL.Exp %arg0 : f32 10 return 11} 12 13func.func @expvec(%arg0 : vector<3xf16>) -> () { 14 // CHECK: spirv.GL.Exp {{%.*}} : vector<3xf16> 15 %2 = spirv.GL.Exp %arg0 : vector<3xf16> 16 return 17} 18 19// ----- 20 21func.func @exp(%arg0 : i32) -> () { 22 // expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values}} 23 %2 = spirv.GL.Exp %arg0 : i32 24 return 25} 26 27// ----- 28 29func.func @exp(%arg0 : vector<5xf32>) -> () { 30 // expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4}} 31 %2 = spirv.GL.Exp %arg0 : vector<5xf32> 32 return 33} 34 35// ----- 36 37func.func @exp(%arg0 : f32, %arg1 : f32) -> () { 38 // expected-error @+1 {{expected ':'}} 39 %2 = spirv.GL.Exp %arg0, %arg1 : i32 40 return 41} 42 43// ----- 44 45func.func @exp(%arg0 : i32) -> () { 46 // expected-error @+1 {{expected non-function type}} 47 %2 = spirv.GL.Exp %arg0 : 48 return 49} 50 51// ----- 52 53//===----------------------------------------------------------------------===// 54// spirv.GL.{F|S|U}{Max|Min} 55//===----------------------------------------------------------------------===// 56 57func.func @fmaxmin(%arg0 : f32, %arg1 : f32) { 58 // CHECK: spirv.GL.FMax {{%.*}}, {{%.*}} : f32 59 %1 = spirv.GL.FMax %arg0, %arg1 : f32 60 // CHECK: spirv.GL.FMin {{%.*}}, {{%.*}} : f32 61 %2 = spirv.GL.FMin %arg0, %arg1 : f32 62 return 63} 64 65func.func @fmaxminvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) { 66 // CHECK: spirv.GL.FMax {{%.*}}, {{%.*}} : vector<3xf16> 67 %1 = spirv.GL.FMax %arg0, %arg1 : vector<3xf16> 68 // CHECK: spirv.GL.FMin {{%.*}}, {{%.*}} : vector<3xf16> 69 %2 = spirv.GL.FMin %arg0, %arg1 : vector<3xf16> 70 return 71} 72 73func.func @fmaxminf64(%arg0 : f64, %arg1 : f64) { 74 // CHECK: spirv.GL.FMax {{%.*}}, {{%.*}} : f64 75 %1 = spirv.GL.FMax %arg0, %arg1 : f64 76 // CHECK: spirv.GL.FMin {{%.*}}, {{%.*}} : f64 77 %2 = spirv.GL.FMin %arg0, %arg1 : f64 78 return 79} 80 81func.func @iminmax(%arg0: i32, %arg1: i32) { 82 // CHECK: spirv.GL.SMax {{%.*}}, {{%.*}} : i32 83 %1 = spirv.GL.SMax %arg0, %arg1 : i32 84 // CHECK: spirv.GL.UMax {{%.*}}, {{%.*}} : i32 85 %2 = spirv.GL.UMax %arg0, %arg1 : i32 86 // CHECK: spirv.GL.SMin {{%.*}}, {{%.*}} : i32 87 %3 = spirv.GL.SMin %arg0, %arg1 : i32 88 // CHECK: spirv.GL.UMin {{%.*}}, {{%.*}} : i32 89 %4 = spirv.GL.UMin %arg0, %arg1 : i32 90 return 91} 92 93// ----- 94 95//===----------------------------------------------------------------------===// 96// spirv.GL.InverseSqrt 97//===----------------------------------------------------------------------===// 98 99func.func @inversesqrt(%arg0 : f32) -> () { 100 // CHECK: spirv.GL.InverseSqrt {{%.*}} : f32 101 %2 = spirv.GL.InverseSqrt %arg0 : f32 102 return 103} 104 105func.func @inversesqrtvec(%arg0 : vector<3xf16>) -> () { 106 // CHECK: spirv.GL.InverseSqrt {{%.*}} : vector<3xf16> 107 %2 = spirv.GL.InverseSqrt %arg0 : vector<3xf16> 108 return 109} 110 111// ----- 112 113//===----------------------------------------------------------------------===// 114// spirv.GL.Sqrt 115//===----------------------------------------------------------------------===// 116 117func.func @sqrt(%arg0 : f32) -> () { 118 // CHECK: spirv.GL.Sqrt {{%.*}} : f32 119 %2 = spirv.GL.Sqrt %arg0 : f32 120 return 121} 122 123func.func @sqrtvec(%arg0 : vector<3xf16>) -> () { 124 // CHECK: spirv.GL.Sqrt {{%.*}} : vector<3xf16> 125 %2 = spirv.GL.Sqrt %arg0 : vector<3xf16> 126 return 127} 128 129//===----------------------------------------------------------------------===// 130// spirv.GL.Cos 131//===----------------------------------------------------------------------===// 132 133func.func @cos(%arg0 : f32) -> () { 134 // CHECK: spirv.GL.Cos {{%.*}} : f32 135 %2 = spirv.GL.Cos %arg0 : f32 136 return 137} 138 139func.func @cosvec(%arg0 : vector<3xf16>) -> () { 140 // CHECK: spirv.GL.Cos {{%.*}} : vector<3xf16> 141 %2 = spirv.GL.Cos %arg0 : vector<3xf16> 142 return 143} 144 145//===----------------------------------------------------------------------===// 146// spirv.GL.Sin 147//===----------------------------------------------------------------------===// 148 149func.func @sin(%arg0 : f32) -> () { 150 // CHECK: spirv.GL.Sin {{%.*}} : f32 151 %2 = spirv.GL.Sin %arg0 : f32 152 return 153} 154 155func.func @sinvec(%arg0 : vector<3xf16>) -> () { 156 // CHECK: spirv.GL.Sin {{%.*}} : vector<3xf16> 157 %2 = spirv.GL.Sin %arg0 : vector<3xf16> 158 return 159} 160 161//===----------------------------------------------------------------------===// 162// spirv.GL.Tan 163//===----------------------------------------------------------------------===// 164 165func.func @tan(%arg0 : f32) -> () { 166 // CHECK: spirv.GL.Tan {{%.*}} : f32 167 %2 = spirv.GL.Tan %arg0 : f32 168 return 169} 170 171func.func @tanvec(%arg0 : vector<3xf16>) -> () { 172 // CHECK: spirv.GL.Tan {{%.*}} : vector<3xf16> 173 %2 = spirv.GL.Tan %arg0 : vector<3xf16> 174 return 175} 176 177//===----------------------------------------------------------------------===// 178// spirv.GL.Acos 179//===----------------------------------------------------------------------===// 180 181func.func @acos(%arg0 : f32) -> () { 182 // CHECK: spirv.GL.Acos {{%.*}} : f32 183 %2 = spirv.GL.Acos %arg0 : f32 184 return 185} 186 187func.func @acosvec(%arg0 : vector<3xf16>) -> () { 188 // CHECK: spirv.GL.Acos {{%.*}} : vector<3xf16> 189 %2 = spirv.GL.Acos %arg0 : vector<3xf16> 190 return 191} 192 193//===----------------------------------------------------------------------===// 194// spirv.GL.Asin 195//===----------------------------------------------------------------------===// 196 197func.func @asin(%arg0 : f32) -> () { 198 // CHECK: spirv.GL.Asin {{%.*}} : f32 199 %2 = spirv.GL.Asin %arg0 : f32 200 return 201} 202 203func.func @asinvec(%arg0 : vector<3xf16>) -> () { 204 // CHECK: spirv.GL.Asin {{%.*}} : vector<3xf16> 205 %2 = spirv.GL.Asin %arg0 : vector<3xf16> 206 return 207} 208 209//===----------------------------------------------------------------------===// 210// spirv.GL.Atan 211//===----------------------------------------------------------------------===// 212 213func.func @atan(%arg0 : f32) -> () { 214 // CHECK: spirv.GL.Atan {{%.*}} : f32 215 %2 = spirv.GL.Atan %arg0 : f32 216 return 217} 218 219func.func @atanvec(%arg0 : vector<3xf16>) -> () { 220 // CHECK: spirv.GL.Atan {{%.*}} : vector<3xf16> 221 %2 = spirv.GL.Atan %arg0 : vector<3xf16> 222 return 223} 224 225//===----------------------------------------------------------------------===// 226// spirv.GL.Sinh 227//===----------------------------------------------------------------------===// 228 229func.func @sinh(%arg0 : f32) -> () { 230 // CHECK: spirv.GL.Sinh {{%.*}} : f32 231 %2 = spirv.GL.Sinh %arg0 : f32 232 return 233} 234 235func.func @sinhvec(%arg0 : vector<3xf16>) -> () { 236 // CHECK: spirv.GL.Sinh {{%.*}} : vector<3xf16> 237 %2 = spirv.GL.Sinh %arg0 : vector<3xf16> 238 return 239} 240 241//===----------------------------------------------------------------------===// 242// spirv.GL.Cosh 243//===----------------------------------------------------------------------===// 244 245func.func @cosh(%arg0 : f32) -> () { 246 // CHECK: spirv.GL.Cosh {{%.*}} : f32 247 %2 = spirv.GL.Cosh %arg0 : f32 248 return 249} 250 251func.func @coshvec(%arg0 : vector<3xf16>) -> () { 252 // CHECK: spirv.GL.Cosh {{%.*}} : vector<3xf16> 253 %2 = spirv.GL.Cosh %arg0 : vector<3xf16> 254 return 255} 256 257//===----------------------------------------------------------------------===// 258// spirv.GL.Pow 259//===----------------------------------------------------------------------===// 260 261func.func @pow(%arg0 : f32, %arg1 : f32) -> () { 262 // CHECK: spirv.GL.Pow {{%.*}}, {{%.*}} : f32 263 %2 = spirv.GL.Pow %arg0, %arg1 : f32 264 return 265} 266 267func.func @powvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) -> () { 268 // CHECK: spirv.GL.Pow {{%.*}}, {{%.*}} : vector<3xf16> 269 %2 = spirv.GL.Pow %arg0, %arg1 : vector<3xf16> 270 return 271} 272 273// ----- 274 275//===----------------------------------------------------------------------===// 276// spirv.GL.Round 277//===----------------------------------------------------------------------===// 278 279func.func @round(%arg0 : f32) -> () { 280 // CHECK: spirv.GL.Round {{%.*}} : f32 281 %2 = spirv.GL.Round %arg0 : f32 282 return 283} 284 285func.func @roundvec(%arg0 : vector<3xf16>) -> () { 286 // CHECK: spirv.GL.Round {{%.*}} : vector<3xf16> 287 %2 = spirv.GL.Round %arg0 : vector<3xf16> 288 return 289} 290 291//===----------------------------------------------------------------------===// 292// spirv.GL.RoundEven 293//===----------------------------------------------------------------------===// 294 295func.func @round_even(%arg0 : f32) -> () { 296 // CHECK: spirv.GL.RoundEven {{%.*}} : f32 297 %2 = spirv.GL.RoundEven %arg0 : f32 298 return 299} 300 301func.func @round_even_vec(%arg0 : vector<3xf16>) -> () { 302 // CHECK: spirv.GL.RoundEven {{%.*}} : vector<3xf16> 303 %2 = spirv.GL.RoundEven %arg0 : vector<3xf16> 304 return 305} 306 307// ----- 308 309//===----------------------------------------------------------------------===// 310// spirv.GL.FClamp 311//===----------------------------------------------------------------------===// 312 313func.func @fclamp(%arg0 : f32, %min : f32, %max : f32) -> () { 314 // CHECK: spirv.GL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32 315 %2 = spirv.GL.FClamp %arg0, %min, %max : f32 316 return 317} 318 319// ----- 320 321func.func @fclamp(%arg0 : vector<3xf32>, %min : vector<3xf32>, %max : vector<3xf32>) -> () { 322 // CHECK: spirv.GL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32> 323 %2 = spirv.GL.FClamp %arg0, %min, %max : vector<3xf32> 324 return 325} 326 327// ----- 328 329//===----------------------------------------------------------------------===// 330// spirv.GL.UClamp 331//===----------------------------------------------------------------------===// 332 333func.func @uclamp(%arg0 : ui32, %min : ui32, %max : ui32) -> () { 334 // CHECK: spirv.GL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : ui32 335 %2 = spirv.GL.UClamp %arg0, %min, %max : ui32 336 return 337} 338 339// ----- 340 341func.func @uclamp(%arg0 : vector<4xi32>, %min : vector<4xi32>, %max : vector<4xi32>) -> () { 342 // CHECK: spirv.GL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xi32> 343 %2 = spirv.GL.UClamp %arg0, %min, %max : vector<4xi32> 344 return 345} 346 347// ----- 348 349func.func @uclamp(%arg0 : si32, %min : si32, %max : si32) -> () { 350 // CHECK: spirv.GL.UClamp 351 %2 = spirv.GL.UClamp %arg0, %min, %max : si32 352 return 353} 354 355// ----- 356 357//===----------------------------------------------------------------------===// 358// spirv.GL.SClamp 359//===----------------------------------------------------------------------===// 360 361func.func @sclamp(%arg0 : si32, %min : si32, %max : si32) -> () { 362 // CHECK: spirv.GL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32 363 %2 = spirv.GL.SClamp %arg0, %min, %max : si32 364 return 365} 366 367// ----- 368 369func.func @sclamp(%arg0 : vector<4xsi32>, %min : vector<4xsi32>, %max : vector<4xsi32>) -> () { 370 // CHECK: spirv.GL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xsi32> 371 %2 = spirv.GL.SClamp %arg0, %min, %max : vector<4xsi32> 372 return 373} 374 375// ----- 376 377func.func @sclamp(%arg0 : i32, %min : i32, %max : i32) -> () { 378 // CHECK: spirv.GL.SClamp 379 %2 = spirv.GL.SClamp %arg0, %min, %max : i32 380 return 381} 382 383// ----- 384 385//===----------------------------------------------------------------------===// 386// spirv.GL.Fma 387//===----------------------------------------------------------------------===// 388 389func.func @fma(%a : f32, %b : f32, %c : f32) -> () { 390 // CHECK: spirv.GL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32 391 %2 = spirv.GL.Fma %a, %b, %c : f32 392 return 393} 394 395// ----- 396 397func.func @fma(%a : vector<3xf32>, %b : vector<3xf32>, %c : vector<3xf32>) -> () { 398 // CHECK: spirv.GL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32> 399 %2 = spirv.GL.Fma %a, %b, %c : vector<3xf32> 400 return 401} 402// ----- 403 404//===----------------------------------------------------------------------===// 405// spirv.GL.FrexpStruct 406//===----------------------------------------------------------------------===// 407 408func.func @frexp_struct(%arg0 : f32) -> () { 409 // CHECK: spirv.GL.FrexpStruct {{%.*}} : f32 -> !spirv.struct<(f32, i32)> 410 %2 = spirv.GL.FrexpStruct %arg0 : f32 -> !spirv.struct<(f32, i32)> 411 return 412} 413 414func.func @frexp_struct_64(%arg0 : f64) -> () { 415 // CHECK: spirv.GL.FrexpStruct {{%.*}} : f64 -> !spirv.struct<(f64, i32)> 416 %2 = spirv.GL.FrexpStruct %arg0 : f64 -> !spirv.struct<(f64, i32)> 417 return 418} 419 420func.func @frexp_struct_vec(%arg0 : vector<3xf32>) -> () { 421 // CHECK: spirv.GL.FrexpStruct {{%.*}} : vector<3xf32> -> !spirv.struct<(vector<3xf32>, vector<3xi32>)> 422 %2 = spirv.GL.FrexpStruct %arg0 : vector<3xf32> -> !spirv.struct<(vector<3xf32>, vector<3xi32>)> 423 return 424} 425 426// ----- 427 428func.func @frexp_struct_mismatch_type(%arg0 : f32) -> () { 429 // expected-error @+1 {{member zero of the resulting struct type must be the same type as the operand}} 430 %2 = spirv.GL.FrexpStruct %arg0 : f32 -> !spirv.struct<(vector<3xf32>, i32)> 431 return 432} 433 434// ----- 435 436func.func @frexp_struct_wrong_type(%arg0 : i32) -> () { 437 // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} 438 %2 = spirv.GL.FrexpStruct %arg0 : i32 -> !spirv.struct<(i32, i32)> 439 return 440} 441 442// ----- 443 444func.func @frexp_struct_mismatch_num_components(%arg0 : vector<3xf32>) -> () { 445 // expected-error @+1 {{member one of the resulting struct type must have the same number of components as the operand type}} 446 %2 = spirv.GL.FrexpStruct %arg0 : vector<3xf32> -> !spirv.struct<(vector<3xf32>, vector<2xi32>)> 447 return 448} 449 450// ----- 451 452func.func @frexp_struct_not_i32(%arg0 : f32) -> () { 453 // expected-error @+1 {{member one of the resulting struct type must be a scalar or vector of 32 bit integer type}} 454 %2 = spirv.GL.FrexpStruct %arg0 : f32 -> !spirv.struct<(f32, i64)> 455 return 456} 457 458// ----- 459 460//===----------------------------------------------------------------------===// 461// spirv.GL.Ldexp 462//===----------------------------------------------------------------------===// 463 464func.func @ldexp(%arg0 : f32, %arg1 : i32) -> () { 465 // CHECK: {{%.*}} = spirv.GL.Ldexp {{%.*}} : f32, {{%.*}} : i32 -> f32 466 %0 = spirv.GL.Ldexp %arg0 : f32, %arg1 : i32 -> f32 467 return 468} 469 470// ----- 471func.func @ldexp_vec(%arg0 : vector<3xf32>, %arg1 : vector<3xi32>) -> () { 472 // CHECK: {{%.*}} = spirv.GL.Ldexp {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xi32> -> vector<3xf32> 473 %0 = spirv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<3xi32> -> vector<3xf32> 474 return 475} 476 477// ----- 478 479func.func @ldexp_wrong_type_scalar(%arg0 : f32, %arg1 : vector<2xi32>) -> () { 480 // expected-error @+1 {{operands must both be scalars or vectors}} 481 %0 = spirv.GL.Ldexp %arg0 : f32, %arg1 : vector<2xi32> -> f32 482 return 483} 484 485// ----- 486 487func.func @ldexp_wrong_type_vec_1(%arg0 : vector<3xf32>, %arg1 : i32) -> () { 488 // expected-error @+1 {{operands must both be scalars or vectors}} 489 %0 = spirv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : i32 -> vector<3xf32> 490 return 491} 492 493// ----- 494 495func.func @ldexp_wrong_type_vec_2(%arg0 : vector<3xf32>, %arg1 : vector<2xi32>) -> () { 496 // expected-error @+1 {{operands must have the same number of elements}} 497 %0 = spirv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<2xi32> -> vector<3xf32> 498 return 499} 500 501// ----- 502 503//===----------------------------------------------------------------------===// 504// spirv.GL.FMix 505//===----------------------------------------------------------------------===// 506 507func.func @fmix(%arg0 : f32, %arg1 : f32, %arg2 : f32) -> () { 508 // CHECK: {{%.*}} = spirv.GL.FMix {{%.*}} : f32, {{%.*}} : f32, {{%.*}} : f32 -> f32 509 %0 = spirv.GL.FMix %arg0 : f32, %arg1 : f32, %arg2 : f32 -> f32 510 return 511} 512 513func.func @fmix_vector(%arg0 : vector<3xf32>, %arg1 : vector<3xf32>, %arg2 : vector<3xf32>) -> () { 514 // CHECK: {{%.*}} = spirv.GL.FMix {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32> -> vector<3xf32> 515 %0 = spirv.GL.FMix %arg0 : vector<3xf32>, %arg1 : vector<3xf32>, %arg2 : vector<3xf32> -> vector<3xf32> 516 return 517} 518 519// ----- 520 521//===----------------------------------------------------------------------===// 522// spirv.GL.Exp 523//===----------------------------------------------------------------------===// 524 525func.func @findumsb(%arg0 : i32) -> () { 526 // CHECK: spirv.GL.FindUMsb {{%.*}} : i32 527 %2 = spirv.GL.FindUMsb %arg0 : i32 528 return 529} 530 531func.func @findumsb_vector(%arg0 : vector<3xi32>) -> () { 532 // CHECK: spirv.GL.FindUMsb {{%.*}} : vector<3xi32> 533 %2 = spirv.GL.FindUMsb %arg0 : vector<3xi32> 534 return 535} 536 537// ----- 538 539func.func @findumsb(%arg0 : i64) -> () { 540 // expected-error @+1 {{operand #0 must be Int32 or vector of Int32}} 541 %2 = spirv.GL.FindUMsb %arg0 : i64 542 return 543} 544 545// ----- 546 547//===----------------------------------------------------------------------===// 548// spirv.GL.Distance 549//===----------------------------------------------------------------------===// 550 551func.func @distance_scalar(%arg0 : f32, %arg1 : f32) { 552 // CHECK: spirv.GL.Distance {{%.*}}, {{%.*}} : f32, f32 -> f32 553 %0 = spirv.GL.Distance %arg0, %arg1 : f32, f32 -> f32 554 return 555} 556 557func.func @distance_vector(%arg0 : vector<3xf32>, %arg1 : vector<3xf32>) { 558 // CHECK: spirv.GL.Distance {{%.*}}, {{%.*}} : vector<3xf32>, vector<3xf32> -> f32 559 %0 = spirv.GL.Distance %arg0, %arg1 : vector<3xf32>, vector<3xf32> -> f32 560 return 561} 562 563// ----- 564 565func.func @distance_invalid_type(%arg0 : i32, %arg1 : i32) { 566 // expected-error @+1 {{'spirv.GL.Distance' op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4/8/16}} 567 %0 = spirv.GL.Distance %arg0, %arg1 : i32, i32 -> f32 568 return 569} 570 571// ----- 572 573func.func @distance_arg_mismatch(%arg0 : vector<3xf32>, %arg1 : vector<4xf32>) { 574 // expected-error @+1 {{'spirv.GL.Distance' op failed to verify that all of {p0, p1} have same type}} 575 %0 = spirv.GL.Distance %arg0, %arg1 : vector<3xf32>, vector<4xf32> -> f32 576 return 577} 578 579// ----- 580 581func.func @distance_invalid_vector_size(%arg0 : vector<5xf32>, %arg1 : vector<5xf32>) { 582 // expected-error @+1 {{'spirv.GL.Distance' op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4/8/16}} 583 %0 = spirv.GL.Distance %arg0, %arg1 : vector<5xf32>, vector<5xf32> -> f32 584 return 585} 586 587// ----- 588 589func.func @distance_invalid_result(%arg0 : f32, %arg1 : f32) { 590 // expected-error @+1 {{'spirv.GL.Distance' op result #0 must be 16/32/64-bit float}} 591 %0 = spirv.GL.Distance %arg0, %arg1 : f32, f32 -> i32 592 return 593} 594 595// ----- 596 597//===----------------------------------------------------------------------===// 598// spirv.GL.Cross 599//===----------------------------------------------------------------------===// 600 601func.func @cross(%arg0 : vector<3xf32>, %arg1 : vector<3xf32>) { 602 %2 = spirv.GL.Cross %arg0, %arg1 : vector<3xf32> 603 // CHECK: %{{.+}} = spirv.GL.Cross %{{.+}}, %{{.+}} : vector<3xf32> 604 return 605} 606 607// ----- 608 609func.func @cross_invalid_type(%arg0 : vector<3xi32>, %arg1 : vector<3xi32>) { 610 // expected-error @+1 {{'spirv.GL.Cross' op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4/8/16, but got 'vector<3xi32>'}} 611 %0 = spirv.GL.Cross %arg0, %arg1 : vector<3xi32> 612 return 613} 614 615// ----- 616 617//===----------------------------------------------------------------------===// 618// spirv.GL.Normalize 619//===----------------------------------------------------------------------===// 620 621func.func @normalize_scalar(%arg0 : f32) { 622 %2 = spirv.GL.Normalize %arg0 : f32 623 // CHECK: %{{.+}} = spirv.GL.Normalize %{{.+}} : f32 624 return 625} 626 627func.func @normalize_vector(%arg0 : vector<3xf32>) { 628 %2 = spirv.GL.Normalize %arg0 : vector<3xf32> 629 // CHECK: %{{.+}} = spirv.GL.Normalize %{{.+}} : vector<3xf32> 630 return 631} 632 633// ----- 634 635func.func @normalize_invalid_type(%arg0 : i32) { 636 // expected-error @+1 {{'spirv.GL.Normalize' op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} 637 %0 = spirv.GL.Normalize %arg0 : i32 638 return 639} 640 641// ----- 642 643//===----------------------------------------------------------------------===// 644// spirv.GL.Reflect 645//===----------------------------------------------------------------------===// 646 647func.func @reflect_scalar(%arg0 : f32, %arg1 : f32) { 648 %2 = spirv.GL.Reflect %arg0, %arg1 : f32 649 // CHECK: %{{.+}} = spirv.GL.Reflect %{{.+}}, %{{.+}} : f32 650 return 651} 652 653func.func @reflect_vector(%arg0 : vector<3xf32>, %arg1 : vector<3xf32>) { 654 %2 = spirv.GL.Reflect %arg0, %arg1 : vector<3xf32> 655 // CHECK: %{{.+}} = spirv.GL.Reflect %{{.+}}, %{{.+}} : vector<3xf32> 656 return 657} 658 659// ----- 660 661func.func @reflect_invalid_type(%arg0 : i32, %arg1 : i32) { 662 // expected-error @+1 {{'spirv.GL.Reflect' op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} 663 %0 = spirv.GL.Reflect %arg0, %arg1 : i32 664 return 665} 666