mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td

   1 //===- SPIRVGLSLOps.td - GLSL extended insts spec file -----*- tablegen -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This is the op definition spec of GLSL extension ops.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef MLIR_DIALECT_SPIRV_IR_GLSL_OPS
  14 #define MLIR_DIALECT_SPIRV_IR_GLSL_OPS
  15
  16 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
  17 include "mlir/Interfaces/SideEffectInterfaces.td"
  18
  19 //===----------------------------------------------------------------------===//
  20 // SPIR-V GLSL 4.50 opcode specification.
  21 //===----------------------------------------------------------------------===//
  22
  23 // Base class for all GLSL ops.
  24 class SPV_GLSLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
  25   SPV_ExtInstOp<mnemonic, "GLSL", "GLSL.std.450", opcode, traits>;
  26
  27 // Base class for GLSL unary ops.
  28 class SPV_GLSLUnaryOp<string mnemonic, int opcode, Type resultType,
  29                       Type operandType, list<OpTrait> traits = []> :
  30   SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
  31
  32   let arguments = (ins
  33     SPV_ScalarOrVectorOf<operandType>:$operand
  34   );
  35
  36   let results = (outs
  37     SPV_ScalarOrVectorOf<resultType>:$result
  38   );
  39
  40   let parser = [{ return parseUnaryOp(parser, result); }];
  41
  42   let printer = [{ return printUnaryOp(getOperation(), p); }];
  43
  44   let verifier = [{ return success(); }];
  45 }
  46
  47 // Base class for GLSL Unary arithmetic ops where return type matches
  48 // the operand type.
  49 class SPV_GLSLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
  50                                 list<OpTrait> traits = []> :
  51   SPV_GLSLUnaryOp<mnemonic, opcode, type, type, traits>;
  52
  53 // Base class for GLSL binary ops.
  54 class SPV_GLSLBinaryOp<string mnemonic, int opcode, Type resultType,
  55                         Type operandType, list<OpTrait> traits = []> :
  56   SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
  57
  58   let arguments = (ins
  59     SPV_ScalarOrVectorOf<operandType>:$lhs,
  60     SPV_ScalarOrVectorOf<operandType>:$rhs
  61   );
  62
  63   let results = (outs
  64     SPV_ScalarOrVectorOf<resultType>:$result
  65   );
  66
  67   let parser = [{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
  68
  69   let printer = [{ return impl::printOneResultOp(getOperation(), p); }];
  70
  71   let verifier = [{ return success(); }];
  72 }
  73
  74 // Base class for GLSL Binary arithmetic ops where operand types and
  75 // return type matches.
  76 class SPV_GLSLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
  77                                  list<OpTrait> traits = []> :
  78   SPV_GLSLBinaryOp<mnemonic, opcode, type, type, traits>;
  79
  80 // Base class for GLSL ternary ops.
  81 class SPV_GLSLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
  82                         list<OpTrait> traits = []> :
  83   SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
  84
  85   let arguments = (ins
  86     SPV_ScalarOrVectorOf<type>:$x,
  87     SPV_ScalarOrVectorOf<type>:$y,
  88     SPV_ScalarOrVectorOf<type>:$z
  89   );
  90
  91   let results = (outs
  92     SPV_ScalarOrVectorOf<type>:$result
  93   );
  94
  95   let parser = [{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
  96
  97   let printer = [{ return impl::printOneResultOp(getOperation(), p); }];
  98
  99   let verifier = [{ return success(); }];
 100 }
 101
 102 // -----
 103
 104 def SPV_GLSLFAbsOp : SPV_GLSLUnaryArithmeticOp<"FAbs", 4, SPV_Float> {
 105   let summary = "Absolute value of operand";
 106
 107   let description = [{
 108     Result is x if x >= 0; otherwise result is -x.
 109
 110     The operand x must be a scalar or vector whose component type is
 111     floating-point.
 112
 113     Result Type and the type of x must be the same type. Results are computed
 114     per component.
 115
 116     <!-- End of AutoGen section -->
 117     ```
 118     float-scalar-vector-type ::= float-type |
 119                                  `vector<` integer-literal `x` float-type `>`
 120     abs-op ::= ssa-id `=` `spv.GLSL.FAbs` ssa-use `:`
 121                float-scalar-vector-type
 122     ```
 123     #### Example:
 124
 125     ```mlir
 126     %2 = spv.GLSL.FAbs %0 : f32
 127     %3 = spv.GLSL.FAbs %1 : vector<3xf16>
 128     ```
 129   }];
 130 }
 131
 132 // -----
 133
 134 def SPV_GLSLSAbsOp : SPV_GLSLUnaryArithmeticOp<"SAbs", 5, SPV_Integer> {
 135   let summary = "Absolute value of operand";
 136
 137   let description = [{
 138     Result is x if x ≥ 0; otherwise result is -x, where x is interpreted as a
 139     signed integer.
 140
 141     Result Type and the type of x must both be integer scalar or integer vector
 142     types. Result Type and operand types must have the same number of components
 143     with the same component width. Results are computed per component.
 144
 145     <!-- End of AutoGen section -->
 146     ```
 147     integer-scalar-vector-type ::= integer-type |
 148                                    `vector<` integer-literal `x` integer-type `>`
 149     abs-op ::= ssa-id `=` `spv.GLSL.SAbs` ssa-use `:`
 150                integer-scalar-vector-type
 151     ```
 152     #### Example:
 153
 154     ```mlir
 155     %2 = spv.GLSL.SAbs %0 : i32
 156     %3 = spv.GLSL.SAbs %1 : vector<3xi16>
 157     ```
 158   }];
 159 }
 160
 161 // -----
 162
 163 def SPV_GLSLCeilOp : SPV_GLSLUnaryArithmeticOp<"Ceil", 9, SPV_Float> {
 164   let summary = "Rounds up to the next whole number";
 165
 166   let description = [{
 167     Result is the value equal to the nearest whole number that is greater than
 168     or equal to x.
 169
 170     The operand x must be a scalar or vector whose component type is
 171     floating-point.
 172
 173     Result Type and the type of x must be the same type. Results are computed
 174     per component.
 175
 176     <!-- End of AutoGen section -->
 177     ```
 178     float-scalar-vector-type ::= float-type |
 179                                  `vector<` integer-literal `x` float-type `>`
 180     ceil-op ::= ssa-id `=` `spv.GLSL.Ceil` ssa-use `:`
 181                 float-scalar-vector-type
 182     ```
 183     #### Example:
 184
 185     ```mlir
 186     %2 = spv.GLSL.Ceil %0 : f32
 187     %3 = spv.GLSL.Ceil %1 : vector<3xf16>
 188     ```
 189   }];
 190 }
 191
 192 // -----
 193
 194 def SPV_GLSLCosOp : SPV_GLSLUnaryArithmeticOp<"Cos", 14, SPV_Float16or32> {
 195   let summary = "Cosine of operand in radians";
 196
 197   let description = [{
 198     The standard trigonometric cosine of x radians.
 199
 200     The operand x must be a scalar or vector whose component type is 16-bit or
 201     32-bit floating-point.
 202
 203     Result Type and the type of x must be the same type. Results are computed
 204     per component.
 205
 206     <!-- End of AutoGen section -->
 207     ```
 208     restricted-float-scalar-type ::=  `f16` | `f32`
 209     restricted-float-scalar-vector-type ::=
 210       restricted-float-scalar-type |
 211       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 212     cos-op ::= ssa-id `=` `spv.GLSL.Cos` ssa-use `:`
 213                restricted-float-scalar-vector-type
 214     ```
 215     #### Example:
 216
 217     ```mlir
 218     %2 = spv.GLSL.Cos %0 : f32
 219     %3 = spv.GLSL.Cos %1 : vector<3xf16>
 220     ```
 221   }];
 222 }
 223
 224 // -----
 225
 226 def SPV_GLSLSinOp : SPV_GLSLUnaryArithmeticOp<"Sin", 13, SPV_Float16or32> {
 227   let summary = "Sine of operand in radians";
 228
 229   let description = [{
 230     The standard trigonometric sine of x radians.
 231
 232     The operand x must be a scalar or vector whose component type is 16-bit or
 233     32-bit floating-point.
 234
 235     Result Type and the type of x must be the same type. Results are computed
 236     per component.
 237
 238     <!-- End of AutoGen section -->
 239     ```
 240     restricted-float-scalar-type ::=  `f16` | `f32`
 241     restricted-float-scalar-vector-type ::=
 242       restricted-float-scalar-type |
 243       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 244     sin-op ::= ssa-id `=` `spv.GLSL.Sin` ssa-use `:`
 245                restricted-float-scalar-vector-type
 246     ```
 247     #### Example:
 248
 249     ```mlir
 250     %2 = spv.GLSL.Sin %0 : f32
 251     %3 = spv.GLSL.Sin %1 : vector<3xf16>
 252     ```
 253   }];
 254 }
 255
 256 // -----
 257
 258 def SPV_GLSLTanOp : SPV_GLSLUnaryArithmeticOp<"Tan", 15, SPV_Float16or32> {
 259   let summary = "Tangent of operand in radians";
 260
 261   let description = [{
 262     The standard trigonometric tangent of x radians.
 263
 264     The operand x must be a scalar or vector whose component type is 16-bit or
 265     32-bit floating-point.
 266
 267     Result Type and the type of x must be the same type. Results are computed
 268     per component.
 269
 270     <!-- End of AutoGen section -->
 271     ```
 272     restricted-float-scalar-type ::=  `f16` | `f32`
 273     restricted-float-scalar-vector-type ::=
 274       restricted-float-scalar-type |
 275       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 276     tan-op ::= ssa-id `=` `spv.GLSL.Tan` ssa-use `:`
 277                restricted-float-scalar-vector-type
 278     ```
 279     #### Example:
 280
 281     ```mlir
 282     %2 = spv.GLSL.Tan %0 : f32
 283     %3 = spv.GLSL.Tan %1 : vector<3xf16>
 284     ```
 285   }];
 286 }
 287
 288 // -----
 289
 290 def SPV_GLSLAsinOp : SPV_GLSLUnaryArithmeticOp<"Asin", 16, SPV_Float16or32> {
 291   let summary = "Arc Sine of operand in radians";
 292
 293   let description = [{
 294     The standard trigonometric arc sine of x radians.
 295
 296     Result is an angle, in radians, whose sine is x. The range of result values
 297     is [-π / 2, π / 2]. Result is undefined if abs x > 1.
 298
 299     The operand x must be a scalar or vector whose component type is 16-bit or
 300     32-bit floating-point.
 301
 302     Result Type and the type of x must be the same type. Results are computed
 303     per component.
 304     <!-- End of AutoGen section -->
 305     ```
 306     restricted-float-scalar-type ::=  `f16` | `f32`
 307     restricted-float-scalar-vector-type ::=
 308       restricted-float-scalar-type |
 309       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 310     asin-op ::= ssa-id `=` `spv.GLSL.Asin` ssa-use `:`
 311                 restricted-float-scalar-vector-type
 312     ```
 313     #### Example:
 314
 315     ```mlir
 316     %2 = spv.GLSL.Asin %0 : f32
 317     %3 = spv.GLSL.Asin %1 : vector<3xf16>
 318     ```
 319   }];
 320 }
 321
 322 // -----
 323
 324 def SPV_GLSLAcosOp : SPV_GLSLUnaryArithmeticOp<"Acos", 17, SPV_Float16or32> {
 325   let summary = "Arc Cosine of operand in radians";
 326
 327   let description = [{
 328     The standard trigonometric arc cosine of x radians.
 329
 330     Result is an angle, in radians, whose cosine is x. The range of result
 331     values is [0, π]. Result is undefined if abs x > 1.
 332
 333     The operand x must be a scalar or vector whose component type is 16-bit or
 334     32-bit floating-point.
 335
 336     Result Type and the type of x must be the same type. Results are computed
 337     per component.
 338     <!-- End of AutoGen section -->
 339     ```
 340     restricted-float-scalar-type ::=  `f16` | `f32`
 341     restricted-float-scalar-vector-type ::=
 342       restricted-float-scalar-type |
 343       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 344     acos-op ::= ssa-id `=` `spv.GLSL.Acos` ssa-use `:`
 345                 restricted-float-scalar-vector-type
 346     ```
 347     #### Example:
 348
 349     ```mlir
 350     %2 = spv.GLSL.Acos %0 : f32
 351     %3 = spv.GLSL.Acos %1 : vector<3xf16>
 352     ```
 353   }];
 354 }
 355
 356 // -----
 357
 358 def SPV_GLSLAtanOp : SPV_GLSLUnaryArithmeticOp<"Atan", 18, SPV_Float16or32> {
 359   let summary = "Arc Tangent of operand in radians";
 360
 361   let description = [{
 362     The standard trigonometric arc tangent of x radians.
 363
 364     Result is an angle, in radians, whose tangent is y_over_x. The range of
 365     result values is [-π / 2, π / 2].
 366
 367     The operand x must be a scalar or vector whose component type is 16-bit or
 368     32-bit floating-point.
 369
 370     Result Type and the type of x must be the same type. Results are computed
 371     per component.
 372     <!-- End of AutoGen section -->
 373     ```
 374     restricted-float-scalar-type ::=  `f16` | `f32`
 375     restricted-float-scalar-vector-type ::=
 376       restricted-float-scalar-type |
 377       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 378     atan-op ::= ssa-id `=` `spv.GLSL.Atan` ssa-use `:`
 379                 restricted-float-scalar-vector-type
 380     ```
 381     #### Example:
 382
 383     ```mlir
 384     %2 = spv.GLSL.Atan %0 : f32
 385     %3 = spv.GLSL.Atan %1 : vector<3xf16>
 386     ```
 387   }];
 388 }
 389
 390 // -----
 391
 392 def SPV_GLSLExpOp : SPV_GLSLUnaryArithmeticOp<"Exp", 27, SPV_Float16or32> {
 393   let summary = "Exponentiation of Operand 1";
 394
 395   let description = [{
 396     Result is the natural exponentiation of x; e^x.
 397
 398     The operand x must be a scalar or vector whose component type is
 399     16-bit or 32-bit floating-point.
 400
 401     Result Type and the type of x must be the same type. Results are
 402     computed per component.";
 403
 404     <!-- End of AutoGen section -->
 405     ```
 406     restricted-float-scalar-type ::=  `f16` | `f32`
 407     restricted-float-scalar-vector-type ::=
 408       restricted-float-scalar-type |
 409       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 410     exp-op ::= ssa-id `=` `spv.GLSL.Exp` ssa-use `:`
 411                restricted-float-scalar-vector-type
 412     ```
 413     #### Example:
 414
 415     ```mlir
 416     %2 = spv.GLSL.Exp %0 : f32
 417     %3 = spv.GLSL.Exp %1 : vector<3xf16>
 418     ```
 419   }];
 420 }
 421
 422 // -----
 423
 424 def SPV_GLSLFloorOp : SPV_GLSLUnaryArithmeticOp<"Floor", 8, SPV_Float> {
 425   let summary = "Rounds down to the next whole number";
 426
 427   let description = [{
 428     Result is the value equal to the nearest whole number that is less than or
 429     equal to x.
 430
 431     The operand x must be a scalar or vector whose component type is
 432     floating-point.
 433
 434     Result Type and the type of x must be the same type. Results are computed
 435     per component.
 436
 437     <!-- End of AutoGen section -->
 438     ```
 439     float-scalar-vector-type ::= float-type |
 440                                  `vector<` integer-literal `x` float-type `>`
 441     floor-op ::= ssa-id `=` `spv.GLSL.Floor` ssa-use `:`
 442                 float-scalar-vector-type
 443     ```
 444     #### Example:
 445
 446     ```mlir
 447     %2 = spv.GLSL.Floor %0 : f32
 448     %3 = spv.GLSL.Floor %1 : vector<3xf16>
 449     ```
 450   }];
 451 }
 452
 453 // -----
 454
 455 def SPV_GLSLRoundOp: SPV_GLSLUnaryArithmeticOp<"Round", 1, SPV_Float> {
 456   let summary = "Rounds to the whole number";
 457
 458   let description = [{
 459     Result is the value equal to the nearest whole number.
 460
 461     The operand x must be a scalar or vector whose component type is
 462     floating-point.
 463
 464     Result Type and the type of x must be the same type. Results are computed
 465     per component.
 466
 467     <!-- End of AutoGen section -->
 468     ```
 469     float-scalar-vector-type ::= float-type |
 470                                  `vector<` integer-literal `x` float-type `>`
 471     floor-op ::= ssa-id `=` `spv.GLSL.Round` ssa-use `:`
 472                 float-scalar-vector-type
 473     ```
 474     #### Example:
 475
 476     ```mlir
 477     %2 = spv.GLSL.Round %0 : f32
 478     %3 = spv.GLSL.Round %1 : vector<3xf16>
 479     ```
 480   }];
 481 }
 482
 483 // -----
 484
 485 def SPV_GLSLInverseSqrtOp : SPV_GLSLUnaryArithmeticOp<"InverseSqrt", 32, SPV_Float> {
 486   let summary = "Reciprocal of sqrt(operand)";
 487
 488   let description = [{
 489     Result is the reciprocal of sqrt x. Result is undefined if x <= 0.
 490
 491     The operand x must be a scalar or vector whose component type is
 492     floating-point.
 493
 494     Result Type and the type of x must be the same type. Results are computed
 495     per component.
 496
 497     <!-- End of AutoGen section -->
 498     ```
 499     float-scalar-vector-type ::= float-type |
 500                                  `vector<` integer-literal `x` float-type `>`
 501     rsqrt-op ::= ssa-id `=` `spv.GLSL.InverseSqrt` ssa-use `:`
 502                  float-scalar-vector-type
 503     ```
 504     #### Example:
 505
 506     ```mlir
 507     %2 = spv.GLSL.InverseSqrt %0 : f32
 508     %3 = spv.GLSL.InverseSqrt %1 : vector<3xf16>
 509     ```
 510   }];
 511 }
 512
 513 // -----
 514
 515 def SPV_GLSLLogOp : SPV_GLSLUnaryArithmeticOp<"Log", 28, SPV_Float16or32> {
 516   let summary = "Natural logarithm of the operand";
 517
 518   let description = [{
 519     Result is the natural logarithm of x, i.e., the value y which satisfies the
 520     equation x = ey. Result is undefined if x <= 0.
 521
 522     The operand x must be a scalar or vector whose component type is 16-bit or
 523     32-bit floating-point.
 524
 525     Result Type and the type of x must be the same type. Results are computed
 526     per component.
 527
 528     <!-- End of AutoGen section -->
 529     ```
 530     restricted-float-scalar-type ::=  `f16` | `f32`
 531     restricted-float-scalar-vector-type ::=
 532       restricted-float-scalar-type |
 533       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 534     log-op ::= ssa-id `=` `spv.GLSL.Log` ssa-use `:`
 535                restricted-float-scalar-vector-type
 536     ```
 537     #### Example:
 538
 539     ```mlir
 540     %2 = spv.GLSL.Log %0 : f32
 541     %3 = spv.GLSL.Log %1 : vector<3xf16>
 542     ```
 543   }];
 544 }
 545
 546 // -----
 547
 548 def SPV_GLSLFMaxOp : SPV_GLSLBinaryArithmeticOp<"FMax", 40, SPV_Float> {
 549   let summary = "Return maximum of two floating-point operands";
 550
 551   let description = [{
 552     Result is y if x < y; otherwise result is x. Which operand is the
 553     result is undefined if one of the operands is a NaN.
 554
 555     The operands must all be a scalar or vector whose component type
 556     is floating-point.
 557
 558     Result Type and the type of all operands must be the same
 559     type. Results are computed per component.
 560
 561     <!-- End of AutoGen section -->
 562     ```
 563     float-scalar-vector-type ::= float-type |
 564                                  `vector<` integer-literal `x` float-type `>`
 565     fmax-op ::= ssa-id `=` `spv.GLSL.FMax` ssa-use `:`
 566                 float-scalar-vector-type
 567     ```
 568     #### Example:
 569
 570     ```mlir
 571     %2 = spv.GLSL.FMax %0, %1 : f32
 572     %3 = spv.GLSL.FMax %0, %1 : vector<3xf16>
 573     ```
 574   }];
 575 }
 576
 577 // -----
 578
 579 def SPV_GLSLSMaxOp : SPV_GLSLBinaryArithmeticOp<"SMax", 42, SPV_Integer> {
 580   let summary = "Return maximum of two signed integer operands";
 581
 582   let description = [{
 583     Result is y if x < y; otherwise result is x, where x and y are interpreted
 584     as signed integers.
 585
 586     Result Type and the type of x and y must both be integer scalar or integer
 587     vector types. Result Type and operand types must have the same number of
 588     components with the same component width. Results are computed per
 589     component.
 590
 591     <!-- End of AutoGen section -->
 592     ```
 593     integer-scalar-vector-type ::= integer-type |
 594                                    `vector<` integer-literal `x` integer-type `>`
 595     smax-op ::= ssa-id `=` `spv.GLSL.SMax` ssa-use `:`
 596                 integer-scalar-vector-type
 597     ```
 598     #### Example:
 599
 600     ```mlir
 601     %2 = spv.GLSL.SMax %0, %1 : i32
 602     %3 = spv.GLSL.SMax %0, %1 : vector<3xi16>
 603     ```
 604   }];
 605 }
 606
 607 // -----
 608
 609 def SPV_GLSLFMinOp : SPV_GLSLBinaryArithmeticOp<"FMin", 37, SPV_Float> {
 610   let summary = "Return minimum of two floating-point operands";
 611
 612   let description = [{
 613     Result is y if y < x; otherwise result is x. Which operand is the result is
 614     undefined if one of the operands is a NaN.
 615
 616     The operands must all be a scalar or vector whose component type is
 617     floating-point.
 618
 619     Result Type and the type of all operands must be the same type. Results are
 620     computed per component.
 621
 622     <!-- End of AutoGen section -->
 623     ```
 624     float-scalar-vector-type ::= float-type |
 625                                  `vector<` integer-literal `x` float-type `>`
 626     fmin-op ::= ssa-id `=` `spv.GLSL.FMin` ssa-use `:`
 627                 float-scalar-vector-type
 628     ```
 629     #### Example:
 630
 631     ```mlir
 632     %2 = spv.GLSL.FMin %0, %1 : f32
 633     %3 = spv.GLSL.FMin %0, %1 : vector<3xf16>
 634     ```
 635   }];
 636 }
 637
 638 // -----
 639
 640 def SPV_GLSLSMinOp : SPV_GLSLBinaryArithmeticOp<"SMin", 39, SPV_Integer> {
 641   let summary = "Return minimum of two signed integer operands";
 642
 643   let description = [{
 644     Result is y if y < x; otherwise result is x, where x and y are interpreted
 645     as signed integers.
 646
 647     Result Type and the type of x and y must both be integer scalar or integer
 648     vector types. Result Type and operand types must have the same number of
 649     components with the same component width. Results are computed per
 650     component.
 651
 652     <!-- End of AutoGen section -->
 653     ```
 654     integer-scalar-vector-type ::= integer-type |
 655                                    `vector<` integer-literal `x` integer-type `>`
 656     smin-op ::= ssa-id `=` `spv.GLSL.SMin` ssa-use `:`
 657                 integer-scalar-vector-type
 658     ```
 659     #### Example:
 660
 661     ```mlir
 662     %2 = spv.GLSL.SMin %0, %1 : i32
 663     %3 = spv.GLSL.SMin %0, %1 : vector<3xi16>
 664     ```
 665   }];
 666 }
 667
 668 // -----
 669
 670 def SPV_GLSLPowOp : SPV_GLSLBinaryArithmeticOp<"Pow", 26, SPV_Float16or32> {
 671   let summary = "Return x raised to the y power of two operands";
 672
 673   let description = [{
 674     Result is x raised to the y power; x^y.
 675
 676     Result is undefined if x = 0 and y ≤ 0.
 677
 678     The operand x and y must be a scalar or vector whose component type is
 679     16-bit or 32-bit floating-point.
 680
 681     Result Type and the type of all operands must be the same type. Results are
 682     computed per component.
 683
 684     <!-- End of AutoGen section -->
 685     ```
 686     restricted-float-scalar-type ::=  `f16` | `f32`
 687     restricted-float-scalar-vector-type ::=
 688       restricted-float-scalar-type |
 689       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 690     pow-op ::= ssa-id `=` `spv.GLSL.Pow` ssa-use `:`
 691                restricted-float-scalar-vector-type
 692     ```
 693     #### Example:
 694
 695     ```mlir
 696     %2 = spv.GLSL.Pow %0, %1 : f32
 697     %3 = spv.GLSL.Pow %0, %1 : vector<3xf16>
 698     ```
 699   }];
 700 }
 701
 702 // -----
 703
 704 def SPV_GLSLFSignOp : SPV_GLSLUnaryArithmeticOp<"FSign", 6, SPV_Float> {
 705   let summary = "Returns the sign of the operand";
 706
 707   let description = [{
 708     Result is 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0.
 709
 710     The operand x must be a scalar or vector whose component type is
 711     floating-point.
 712
 713     Result Type and the type of x must be the same type. Results are computed
 714     per component.
 715
 716     <!-- End of AutoGen section -->
 717     ```
 718     float-scalar-vector-type ::= float-type |
 719                                  `vector<` integer-literal `x` float-type `>`
 720     sign-op ::= ssa-id `=` `spv.GLSL.FSign` ssa-use `:`
 721                 float-scalar-vector-type
 722     ```
 723     #### Example:
 724
 725     ```mlir
 726     %2 = spv.GLSL.FSign %0 : f32
 727     %3 = spv.GLSL.FSign %1 : vector<3xf16>
 728     ```
 729   }];
 730 }
 731
 732 // -----
 733
 734 def SPV_GLSLSSignOp : SPV_GLSLUnaryArithmeticOp<"SSign", 7, SPV_Integer> {
 735   let summary = "Returns the sign of the operand";
 736
 737   let description = [{
 738     Result is 1 if x > 0, 0 if x = 0, or -1 if x < 0, where x is interpreted as
 739     a signed integer.
 740
 741     Result Type and the type of x must both be integer scalar or integer vector
 742     types. Result Type and operand types must have the same number of components
 743     with the same component width. Results are computed per component.
 744
 745     <!-- End of AutoGen section -->
 746     ```
 747     integer-scalar-vector-type ::= integer-type |
 748                                    `vector<` integer-literal `x` integer-type `>`
 749     sign-op ::= ssa-id `=` `spv.GLSL.SSign` ssa-use `:`
 750                 integer-scalar-vector-type
 751     ```
 752     #### Example:
 753
 754     ```mlir
 755     %2 = spv.GLSL.SSign %0 : i32
 756     %3 = spv.GLSL.SSign %1 : vector<3xi16>
 757     ```
 758   }];
 759 }
 760
 761 // -----
 762
 763 def SPV_GLSLSqrtOp : SPV_GLSLUnaryArithmeticOp<"Sqrt", 31, SPV_Float> {
 764   let summary = "Returns the square root of the operand";
 765
 766   let description = [{
 767     Result is the square root of x. Result is undefined if x < 0.
 768
 769     The operand x must be a scalar or vector whose component type is
 770     floating-point.
 771
 772     Result Type and the type of x must be the same type. Results are computed
 773     per component.
 774
 775     <!-- End of AutoGen section -->
 776     ```
 777     float-scalar-vector-type ::= float-type |
 778                                  `vector<` integer-literal `x` float-type `>`
 779     sqrt-op ::= ssa-id `=` `spv.GLSL.Sqrt` ssa-use `:`
 780                 float-scalar-vector-type
 781     ```
 782     #### Example:
 783
 784     ```mlir
 785     %2 = spv.GLSL.Sqrt %0 : f32
 786     %3 = spv.GLSL.Sqrt %1 : vector<3xf16>
 787     ```
 788   }];
 789 }
 790
 791 // -----
 792
 793 def SPV_GLSLSinhOp : SPV_GLSLUnaryArithmeticOp<"Sinh", 19, SPV_Float16or32> {
 794   let summary = "Hyperbolic sine of operand in radians";
 795
 796   let description = [{
 797     Hyperbolic sine of x radians.
 798
 799     The operand x must be a scalar or vector whose component type is 16-bit or
 800     32-bit floating-point.
 801
 802     Result Type and the type of x must be the same type. Results are computed
 803     per component.
 804
 805     <!-- End of AutoGen section -->
 806     ```
 807     restricted-float-scalar-type ::=  `f16` | `f32`
 808     restricted-float-scalar-vector-type ::=
 809       restricted-float-scalar-type |
 810       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 811     sinh-op ::= ssa-id `=` `spv.GLSL.Sinh` ssa-use `:`
 812                 restricted-float-scalar-vector-type
 813     ```
 814     #### Example:
 815
 816     ```mlir
 817     %2 = spv.GLSL.Sinh %0 : f32
 818     %3 = spv.GLSL.Sinh %1 : vector<3xf16>
 819     ```
 820   }];
 821 }
 822
 823 // -----
 824
 825 def SPV_GLSLCoshOp : SPV_GLSLUnaryArithmeticOp<"Cosh", 20, SPV_Float16or32> {
 826   let summary = "Hyperbolic cosine of operand in radians";
 827
 828   let description = [{
 829     Hyperbolic cosine of x radians.
 830
 831     The operand x must be a scalar or vector whose component type is 16-bit or
 832     32-bit floating-point.
 833
 834     Result Type and the type of x must be the same type. Results are computed
 835     per component.
 836
 837     <!-- End of AutoGen section -->
 838     ```
 839     restricted-float-scalar-type ::=  `f16` | `f32`
 840     restricted-float-scalar-vector-type ::=
 841       restricted-float-scalar-type |
 842       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 843     cosh-op ::= ssa-id `=` `spv.GLSL.Cosh` ssa-use `:`
 844                 restricted-float-scalar-vector-type
 845     ```
 846     #### Example:
 847
 848     ```mlir
 849     %2 = spv.GLSL.Cosh %0 : f32
 850     %3 = spv.GLSL.Cosh %1 : vector<3xf16>
 851     ```
 852   }];
 853 }
 854
 855 // -----
 856
 857 def SPV_GLSLTanhOp : SPV_GLSLUnaryArithmeticOp<"Tanh", 21, SPV_Float16or32> {
 858   let summary = "Hyperbolic tangent of operand in radians";
 859
 860   let description = [{
 861     Hyperbolic tangent of x radians.
 862
 863     The operand x must be a scalar or vector whose component type is 16-bit or
 864     32-bit floating-point.
 865
 866     Result Type and the type of x must be the same type. Results are computed
 867     per component.
 868
 869     <!-- End of AutoGen section -->
 870     ```
 871     restricted-float-scalar-type ::=  `f16` | `f32`
 872     restricted-float-scalar-vector-type ::=
 873       restricted-float-scalar-type |
 874       `vector<` integer-literal `x` restricted-float-scalar-type `>`
 875     tanh-op ::= ssa-id `=` `spv.GLSL.Tanh` ssa-use `:`
 876                 restricted-float-scalar-vector-type
 877     ```
 878     #### Example:
 879
 880     ```mlir
 881     %2 = spv.GLSL.Tanh %0 : f32
 882     %3 = spv.GLSL.Tanh %1 : vector<3xf16>
 883     ```
 884   }];
 885 }
 886
 887 // -----
 888
 889 def SPV_GLSLFClampOp : SPV_GLSLTernaryArithmeticOp<"FClamp", 43, SPV_Float> {
 890   let summary = "Clamp x between min and max values.";
 891
 892   let description = [{
 893     Result is min(max(x, minVal), maxVal). The resulting value is undefined if
 894     minVal > maxVal. The semantics used by min() and max() are those of FMin and
 895     FMax.
 896
 897     The operands must all be a scalar or vector whose component type is
 898     floating-point.
 899
 900     Result Type and the type of all operands must be the same type. Results are
 901     computed per component.
 902
 903     <!-- End of AutoGen section -->
 904     ```
 905     fclamp-op ::= ssa-id `=` `spv.GLSL.FClamp` ssa-use, ssa-use, ssa-use `:`
 906                float-scalar-vector-type
 907     ```
 908     #### Example:
 909
 910     ```mlir
 911     %2 = spv.GLSL.FClamp %x, %min, %max : f32
 912     %3 = spv.GLSL.FClamp %x, %min, %max : vector<3xf16>
 913     ```
 914   }];
 915 }
 916
 917 // -----
 918
 919 def SPV_GLSLUClampOp : SPV_GLSLTernaryArithmeticOp<"UClamp", 44, SPV_SignlessOrUnsignedInt> {
 920   let summary = "Clamp x between min and max values.";
 921
 922   let description = [{
 923     Result is min(max(x, minVal), maxVal), where x, minVal and maxVal are
 924     interpreted as unsigned integers. The resulting value is undefined if
 925     minVal > maxVal.
 926
 927     Result Type and the type of the operands must both be integer scalar or
 928     integer vector types. Result Type and operand types must have the same number
 929     of components with the same component width. Results are computed per
 930     component.
 931
 932     <!-- End of AutoGen section -->
 933     ```
 934     uclamp-op ::= ssa-id `=` `spv.GLSL.UClamp` ssa-use, ssa-use, ssa-use `:`
 935                unsgined-signless-scalar-vector-type
 936     ```
 937     #### Example:
 938
 939     ```mlir
 940     %2 = spv.GLSL.UClamp %x, %min, %max : i32
 941     %3 = spv.GLSL.UClamp %x, %min, %max : vector<3xui16>
 942     ```
 943   }];
 944 }
 945
 946 // -----
 947
 948 def SPV_GLSLSClampOp : SPV_GLSLTernaryArithmeticOp<"SClamp", 45, SPV_SignedInt> {
 949   let summary = "Clamp x between min and max values.";
 950
 951   let description = [{
 952     Result is min(max(x, minVal), maxVal), where x, minVal and maxVal are
 953     interpreted as signed integers. The resulting value is undefined if
 954     minVal > maxVal.
 955
 956     Result Type and the type of the operands must both be integer scalar or
 957     integer vector types. Result Type and operand types must have the same number
 958     of components with the same component width. Results are computed per
 959     component.
 960
 961     <!-- End of AutoGen section -->
 962     ```
 963     uclamp-op ::= ssa-id `=` `spv.GLSL.UClamp` ssa-use, ssa-use, ssa-use `:`
 964                sgined-scalar-vector-type
 965     ```
 966     #### Example:
 967
 968     ```mlir
 969     %2 = spv.GLSL.SClamp %x, %min, %max : si32
 970     %3 = spv.GLSL.SClamp %x, %min, %max : vector<3xsi16>
 971     ```
 972   }];
 973 }
 974
 975 #endif // MLIR_DIALECT_SPIRV_IR_GLSL_OPS