//===- SPIRVCLOps.td - OpenCL extended insts spec file ----*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This is the op definition spec of OpenCL extension ops.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_DIALECT_SPIRV_IR_CL_OPS
#define MLIR_DIALECT_SPIRV_IR_CL_OPS

include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"

//===----------------------------------------------------------------------===//
// SPIR-V OpenCL opcode specification.
//===----------------------------------------------------------------------===//

// Base class for all OpenCL ops.
class SPIRV_CLOp<string mnemonic, int opcode, list<Trait> traits = []> :
  SPIRV_ExtInstOp<mnemonic, "CL", "OpenCL.std", opcode, traits> {

  let availability = [
    MinVersion<SPIRV_V_1_0>,
    MaxVersion<SPIRV_V_1_6>,
    Extension<[]>,
    Capability<[SPIRV_C_Kernel]>
  ];
}

// Base class for OpenCL unary ops.
class SPIRV_CLUnaryOp<string mnemonic, int opcode, Type resultType,
                      Type operandType, list<Trait> traits = []> :
  SPIRV_CLOp<mnemonic, opcode, !listconcat([Pure], traits)> {

  let arguments = (ins
    SPIRV_ScalarOrVectorOf<operandType>:$operand
  );

  let results = (outs
    SPIRV_ScalarOrVectorOf<resultType>:$result
  );

  let assemblyFormat = "$operand `:` type($operand) attr-dict";

  let hasVerifier = 0;
}

// Base class for OpenCL Unary arithmetic ops where return type matches
// the operand type.
class SPIRV_CLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
                                list<Trait> traits = []> :
  SPIRV_CLUnaryOp<mnemonic, opcode, type, type,
                 traits # [SameOperandsAndResultType]>;

// Base class for OpenCL binary ops.
class SPIRV_CLBinaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<Trait> traits = []> :
  SPIRV_CLOp<mnemonic, opcode, !listconcat([Pure], traits)> {

  let arguments = (ins
    SPIRV_ScalarOrVectorOf<operandType>:$lhs,
    SPIRV_ScalarOrVectorOf<operandType>:$rhs
  );

  let results = (outs
    SPIRV_ScalarOrVectorOf<resultType>:$result
  );

  let hasVerifier = 0;
}

// Base class for OpenCL Binary arithmetic ops where operand types and
// return type matches.
class SPIRV_CLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
                                 list<Trait> traits = []> :
  SPIRV_CLBinaryOp<mnemonic, opcode, type, type,
                  traits # [SameOperandsAndResultType]> {
  let assemblyFormat = "operands attr-dict `:` type($result)";
}

// Base class for OpenCL binary ops.
class SPIRV_CLTernaryOp<string mnemonic, int opcode, Type resultType,
                      Type operandType, list<Trait> traits = []> :
  SPIRV_CLOp<mnemonic, opcode, !listconcat([Pure], traits)> {

  let arguments = (ins
    SPIRV_ScalarOrVectorOf<operandType>:$x,
    SPIRV_ScalarOrVectorOf<operandType>:$y,
    SPIRV_ScalarOrVectorOf<operandType>:$z
  );

  let results = (outs
    SPIRV_ScalarOrVectorOf<resultType>:$result
  );

  let hasVerifier = 0;
}

// Base class for OpenCL Ternary arithmetic ops where operand types and
// return type matches.
class SPIRV_CLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
                                  list<Trait> traits = []> :
  SPIRV_CLTernaryOp<mnemonic, opcode, type, type,
                  traits # [SameOperandsAndResultType]> {
  let assemblyFormat = "operands attr-dict `:` type($result)";
}



// -----

def SPIRV_CLAtan2Op : SPIRV_CLBinaryArithmeticOp<"atan2", 7, SPIRV_Float > {
  let summary = "Compute the arc tangent of y / x.";

  let description = [{
    Result is an angle in radians.

    Result Type, y and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.atan2 %0, %1 : f32
    %3 = spirv.CL.atan2 %0, %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLAcosOp : SPIRV_CLUnaryArithmeticOp<"acos", 0, SPIRV_Float > {
  let summary = "Compute the arc cosine of x.";

  let description = [{
    Result is an angle in radians.

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.acos %0 : f32
    %3 = spirv.CL.acos %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLAcoshOp : SPIRV_CLUnaryArithmeticOp<"acosh", 1, SPIRV_Float > {
  let summary = "Compute the inverse hyperbolic cosine of x .";

  let description = [{
    Result is an angle in radians.

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.acosh %0 : f32
    %3 = spirv.CL.acosh %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLAsinOp : SPIRV_CLUnaryArithmeticOp<"asin", 3, SPIRV_Float > {
  let summary = "Compute the arc sine of x.";

  let description = [{
    Result is an angle in radians.

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.asin %0 : f32
    %3 = spirv.CL.asin %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLAsinhOp : SPIRV_CLUnaryArithmeticOp<"asinh", 4, SPIRV_Float > {
  let summary = "Compute the inverse hyperbolic sine of x.";

  let description = [{
    Result is an angle in radians.

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.asinh %0 : f32
    %3 = spirv.CL.asinh %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLAtanOp : SPIRV_CLUnaryArithmeticOp<"atan", 6, SPIRV_Float > {
  let summary = "Compute the arc tangent of x.";

  let description = [{
    Result is an angle in radians.

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.atan %0 : f32
    %3 = spirv.CL.atan %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLAtanhOp : SPIRV_CLUnaryArithmeticOp<"atanh", 8, SPIRV_Float > {
  let summary = "Compute the hyperbolic arc tangent of x.";

  let description = [{
    Result is an angle in radians.

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.atanh %0 : f32
    %3 = spirv.CL.atanh %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLCbrtOp : SPIRV_CLUnaryArithmeticOp<"cbrt", 11, SPIRV_Float> {
  let summary = "Compute the cube root of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.cbrt %0 : f32
    %3 = spirv.CL.cbrt %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLCeilOp : SPIRV_CLUnaryArithmeticOp<"ceil", 12, SPIRV_Float> {
  let summary = [{
    Round x to integral value using the round to positive infinity rounding
    mode.
  }];

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.ceil %0 : f32
    %3 = spirv.CL.ceil %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLCosOp : SPIRV_CLUnaryArithmeticOp<"cos", 14, SPIRV_Float> {
  let summary = "Compute the cosine of x radians.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.cos %0 : f32
    %3 = spirv.CL.cos %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLCoshOp : SPIRV_CLUnaryArithmeticOp<"cosh", 15, SPIRV_Float > {
  let summary = "Compute the hyperbolic cosine of x radians.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.cosh %0 : f32
    %3 = spirv.CL.cosh %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLErfcOp : SPIRV_CLUnaryArithmeticOp<"erfc", 17, SPIRV_Float> {
  let summary = [{
    Complementary error function of x.
  }];

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.erfc %0 : f32
    %3 = spirv.CL.erfc %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLErfOp : SPIRV_CLUnaryArithmeticOp<"erf", 18, SPIRV_Float> {
  let summary = [{
    Error function of x encountered in integrating the normal distribution.
  }];

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.erf %0 : f32
    %3 = spirv.CL.erf %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLExpOp : SPIRV_CLUnaryArithmeticOp<"exp", 19, SPIRV_Float> {
  let summary = "Exponentiation of Operand 1";

  let description = [{
    Compute the base-e exponential of x. (i.e. ex)

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand,
    must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.exp %0 : f32
    %3 = spirv.CL.exp %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLExp2Op : SPIRV_CLUnaryArithmeticOp<"exp2", 20, SPIRV_Float> {
  let summary = "Compute the base-2 exponential of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand,
    must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.exp2 %0 : f32
    %3 = spirv.CL.exp2 %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLExp10Op : SPIRV_CLUnaryArithmeticOp<"exp10", 21, SPIRV_Float> {
  let summary = "Compute the base-10 exponential of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand,
    must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.exp10 %0 : f32
    %3 = spirv.CL.exp10 %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLExpm1Op : SPIRV_CLUnaryArithmeticOp<"expm1", 22, SPIRV_Float> {
  let summary = "Compute the base-e exponential of x minus 1.0.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand,
    must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.expm1 %0 : f32
    %3 = spirv.CL.expm1 %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLFAbsOp : SPIRV_CLUnaryArithmeticOp<"fabs", 23, SPIRV_Float> {
  let summary = "Absolute value of operand";

  let description = [{
    Compute the absolute value of x.

    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand,
    must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.fabs %0 : f32
    %3 = spirv.CL.fabs %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLFMaxOp : SPIRV_CLBinaryArithmeticOp<"fmax", 27, SPIRV_Float> {
  let summary = "Return maximum of two floating-point operands";

  let description = [{
    Returns y if x < y, otherwise it returns x. If one argument is a NaN,
    Fmax returns the other argument. If both arguments are NaNs, Fmax returns a NaN.

    Result Type, x and y must be floating-point or vector(2,3,4,8,16)
    of floating-point values.

    All of the operands, including the Result Type operand,
    must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.fmax %0, %1 : f32
    %3 = spirv.CL.fmax %0, %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLFMinOp : SPIRV_CLBinaryArithmeticOp<"fmin", 28, SPIRV_Float> {
  let summary = "Return minimum of two floating-point operands";

  let description = [{
    Returns y if y < x, otherwise it returns x. If one argument is a NaN, Fmin returns the other argument.
    If both arguments are NaNs, Fmin returns a NaN.

    Result Type,x and y must be floating-point or vector(2,3,4,8,16) of floating-point values.

    All of the operands, including the Result Type operand, must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.fmin %0, %1 : f32
    %3 = spirv.CL.fmin %0, %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLFloorOp : SPIRV_CLUnaryArithmeticOp<"floor", 25, SPIRV_Float> {
  let summary = [{
    Round x to the integral value using the round to negative infinity
    rounding mode.
  }];

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.floor %0 : f32
    %3 = spirv.CL.floor %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLFmaOp : SPIRV_CLTernaryArithmeticOp<"fma", 26, SPIRV_Float> {
  let summary = [{
    Compute the correctly rounded floating-point representation of the sum
    of c with the infinitely precise product of a and b. Rounding of
    intermediate products shall not occur. Edge case results are per the
    IEEE 754-2008 standard.
  }];

  let description = [{
    Result Type, a, b and c must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %0 = spirv.CL.fma %a, %b, %c : f32
    %1 = spirv.CL.fma %a, %b, %c : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLLdexpOp : SPIRV_CLOp<"ldexp", 34, [Pure, AllTypesMatch<["x", "y"]>]> {
  let summary = "Builds y such that y = significand * 2^exponent.";

  let description = [{
    Builds a floating-point number from x and the corresponding
    integral exponent of two in exp:

    significand * 2^exponent

    The operand x must be a scalar or vector whose component type is
    floating-point.

    The exp operand must be a scalar or vector with integer component type.
    The number of components in x and exp must be the same.

    Result Type must be the same type as the type of x. Results are computed
    per component.

    #### Example:

    ```mlir
    %y = spirv.CL.ldexp %x, %exp : f32, i32 -> f32
    %y = spirv.CL.ldexp %x, %exp : vector<3xf32>, vector<3xi32> -> vector<3xf32>
    ```
  }];

  let arguments = (ins
    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$x,
    SPIRV_ScalarOrVectorOf<SPIRV_Integer>:$exp
  );

  let results = (outs
    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$y
  );

  let assemblyFormat = [{
    attr-dict $x `,` $exp `:` type($x) `,` type($exp) `->` type($y)
  }];
}

// -----

def SPIRV_CLLogOp : SPIRV_CLUnaryArithmeticOp<"log", 37, SPIRV_Float> {
  let summary = "Compute the natural logarithm of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.log %0 : f32
    %3 = spirv.CL.log %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLLog2Op : SPIRV_CLUnaryArithmeticOp<"log2", 38, SPIRV_Float> {
  let summary = "Compute the base-2 logarithm of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.log2 %0 : f32
    %3 = spirv.CL.log2 %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLLog10Op : SPIRV_CLUnaryArithmeticOp<"log10", 39, SPIRV_Float> {
  let summary = "Compute the base-10 logarithm of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.log10 %0 : f32
    %3 = spirv.CL.log10 %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLLog1pOp : SPIRV_CLUnaryArithmeticOp<"log1p", 40, SPIRV_Float> {
  let summary = "Compute the natural logarithm of x + 1.0.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.log1p %0 : f32
    %3 = spirv.CL.log1p %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLMixOp : SPIRV_CLTernaryArithmeticOp<"mix", 99, SPIRV_Float> {
  let summary = "Returns the linear blend of x & y implemented as: x + (y - x) * a";

  let description = [{
    Result Type, x, y and a must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    Note: This instruction can be implemented using contractions such as mad
    or fma.

    #### Example:

    ```mlir
    %0 = spirv.CL.mix %a, %b, %c : f32
    %1 = spirv.CL.mix %a, %b, %c : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLPowOp : SPIRV_CLBinaryArithmeticOp<"pow", 48, SPIRV_Float> {
  let summary = "Compute x to the power y.";

  let description = [{
    Result Type, x and y must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.pow %0, %1 : f32
    %3 = spirv.CL.pow %0, %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLPownOp : SPIRV_CLOp<"pown", 49, [Pure, AllTypesMatch<["x", "result"]>]> {
  let summary = "Compute x to the power y, where y is an integer.";

  let description = [{
    Result is x raised to the power y, where y is an integer.

    The operand x must be a scalar or vector whose component type is
    floating-point.

    The y operand must be a scalar or vector with integer component type.
    The number of components in x and y must be the same.

    Result Type must be the same type as the type of x. Results are computed
    per component.

    #### Example:

    ```mlir
    %2 = spirv.CL.pown %0, %1 : f32, i32 -> f32
    %2 = spirv.CL.pown %0, %1 : vector<3xf32>, vector<3xi32> -> vector<3xf32>
    ```
  }];

  let arguments = (ins
    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$x,
    SPIRV_ScalarOrVectorOf<SPIRV_Integer>:$y
  );

  let results = (outs
    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$result
  );

  let assemblyFormat = [{
    attr-dict $x `,` $y `:` type($x) `,` type($y) `->` type($result)
  }];
}

// -----

def SPIRV_CLRintOp : SPIRV_CLUnaryArithmeticOp<"rint", 53, SPIRV_Float> {
  let summary = [{
    Round x to integral value (using round to nearest even rounding mode) in
    floating-point format.
  }];

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %0 = spirv.CL.rint %0 : f32
    %1 = spirv.CL.rint %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLRootnOp : SPIRV_CLOp<"rootn", 54, [Pure, AllTypesMatch<["x", "result"]>]> {
  let summary = "Compute the n-th root of x, where n is an integer.";

  let description = [{
    Result is the n-th root of x, where n is an integer.

    The operand x must be a scalar or vector whose component type is
    floating-point.

    The n operand must be a scalar or vector with integer component type.
    The number of components in x and n must be the same.

    Result Type must be the same type as the type of x. Results are computed
    per component.

    #### Example:

    ```mlir
    %2 = spirv.CL.rootn %0, %1 : f32, i32 -> f32
    %2 = spirv.CL.rootn %0, %1 : vector<3xf32>, vector<3xi32> -> vector<3xf32>
    ```
  }];

  let arguments = (ins
    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$x,
    SPIRV_ScalarOrVectorOf<SPIRV_Integer>:$n
  );

  let results = (outs
    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$result
  );

  let assemblyFormat = [{
    attr-dict $x `,` $n `:` type($x) `,` type($n) `->` type($result)
  }];
}

// -----

def SPIRV_CLRoundOp : SPIRV_CLUnaryArithmeticOp<"round", 55, SPIRV_Float> {
  let summary = [{
    Return the integral value nearest to x rounding halfway cases away from
    zero, regardless of the current rounding direction.
  }];

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.round %0 : f32
    %3 = spirv.CL.round %0 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLRsqrtOp : SPIRV_CLUnaryArithmeticOp<"rsqrt", 56, SPIRV_Float> {
  let summary = "Compute inverse square root of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.rsqrt %0 : f32
    %3 = spirv.CL.rsqrt %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLSAbsOp : SPIRV_CLUnaryArithmeticOp<"s_abs", 141, SPIRV_Integer> {
  let summary = "Absolute value of operand";

  let description = [{
    Returns |x|, where x is treated as signed integer.

    Result Type and x must be integer or vector(2,3,4,8,16) of
    integer values.

    All of the operands, including the Result Type operand,
    must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.s_abs %0 : i32
    %3 = spirv.CL.s_abs %1 : vector<3xi16>
    ```
  }];
}

// -----

def SPIRV_CLClzOp : SPIRV_CLUnaryArithmeticOp<"clz", 151, SPIRV_Integer> {
  let summary = "Count leading zeros in operand";

  let description = [{
    Returns the number of most-significant 0-bits in x.

    Result Type and x must be integer or vector(2,3,4,8,16) of
    integer values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.clz %0 : i32
    %3 = spirv.CL.clz %1 : vector<3xi16>
    ```
  }];
}

// -----

def SPIRV_CLSMaxOp : SPIRV_CLBinaryArithmeticOp<"s_max", 156, SPIRV_Integer> {
  let summary = "Return maximum of two signed integer operands";

  let description = [{
    Returns y if x < y, otherwise it returns x, where x and y are treated as signed integers.

    Result Type,x and y must be integer or vector(2,3,4,8,16) of integer values.

    All of the operands, including the Result Type operand, must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.s_max %0, %1 : i32
    %3 = spirv.CL.s_max %0, %1 : vector<3xi16>
    ```
  }];
}

// -----

def SPIRV_CLSMinOp : SPIRV_CLBinaryArithmeticOp<"s_min", 158, SPIRV_Integer> {
  let summary = "Return minimum of two signed integer operands";

  let description = [{
    Returns y if x < y, otherwise it returns x, where x and y are treated as signed integers.

    Result Type,x and y must be integer or vector(2,3,4,8,16) of integer values.

    All of the operands, including the Result Type operand, must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.s_min %0, %1 : i32
    %3 = spirv.CL.s_min %0, %1 : vector<3xi16>
    ```
  }];
}

// -----

def SPIRV_CLSinOp : SPIRV_CLUnaryArithmeticOp<"sin", 57, SPIRV_Float> {
  let summary = "Compute sine of x radians.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.sin %0 : f32
    %3 = spirv.CL.sin %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLSinhOp : SPIRV_CLUnaryArithmeticOp<"sinh", 59, SPIRV_Float > {
  let summary = "Compute hyperbolic sine of x radians.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.sinh %0 : f32
    %3 = spirv.CL.sinh %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLSqrtOp : SPIRV_CLUnaryArithmeticOp<"sqrt", 61, SPIRV_Float> {
  let summary = "Compute square root of x.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.sqrt %0 : f32
    %3 = spirv.CL.sqrt %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLTanOp : SPIRV_CLUnaryArithmeticOp<"tan", 62, SPIRV_Float > {
  let summary = "Compute tangent of x radians.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.tan %0 : f32
    %3 = spirv.CL.tan %1 : vector<4xf16>
    ```
  }];
}

// -----

def SPIRV_CLTanhOp : SPIRV_CLUnaryArithmeticOp<"tanh", 63, SPIRV_Float> {
  let summary = "Compute hyperbolic tangent of x radians.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.tanh %0 : f32
    %3 = spirv.CL.tanh %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLTruncOp : SPIRV_CLUnaryArithmeticOp<"trunc", 66, SPIRV_Float> {
  let summary = "Round to integral value using the round to zero rounding mode.";

  let description = [{
    Result Type and x must be floating-point or vector(2,3,4,8,16) of
    floating-point values.

    All of the operands, including the Result Type operand, must be of the
    same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.trunc %0 : f32
    %3 = spirv.CL.trunc %1 : vector<3xf16>
    ```
  }];
}

// -----

def SPIRV_CLUMaxOp : SPIRV_CLBinaryArithmeticOp<"u_max", 157, SPIRV_Integer> {
  let summary = "Return maximum of two unsigned integer operands";

  let description = [{
    Returns y if x < y, otherwise it returns x, where x and y are treated as unsigned integers.

    Result Type,x and y must be integer or vector(2,3,4,8,16) of integer values.

    All of the operands, including the Result Type operand, must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.u_max %0, %1 : i32
    %3 = spirv.CL.u_max %0, %1 : vector<3xi16>
    ```
  }];
}

// -----

def SPIRV_CLUMinOp : SPIRV_CLBinaryArithmeticOp<"u_min", 159, SPIRV_Integer> {
  let summary = "Return minimum of two unsigned integer operands";

  let description = [{
    Returns y if x < y, otherwise it returns x, where x and y are treated as unsigned integers.

    Result Type,x and y must be integer or vector(2,3,4,8,16) of integer values.

    All of the operands, including the Result Type operand, must be of the same type.

    #### Example:

    ```mlir
    %2 = spirv.CL.u_min %0, %1 : i32
    %3 = spirv.CL.u_min %0, %1 : vector<3xi16>
    ```
  }];
}

// -----

def SPIRV_CLPrintfOp : SPIRV_CLOp<"printf", 184, []> {
  let summary = [{
    The printf extended instruction writes output to an implementation-
    defined stream such as stdout under control of the string pointed to by
    format that specifies how subsequent arguments are converted for output.
  }];

  let description = [{
    printf returns 0 if it was executed successfully and -1 otherwise.

    Result Type must be i32.

    Format must be a pointer(constant) to i8. If there are insufficient 
    arguments for the format, the behavior is undefined. If the format 
    is exhausted while arguments remain, the excess arguments are evaluated
    (as always) but are otherwise ignored. The printf instruction returns 
    when the end of the format string is encountered.

    <!-- End of AutoGen section -->

    #### Example:

    ```mlir
    %0 = spirv.CL.printf %fmt %1, %2  : !spirv.ptr<i8, UniformConstant>, i32, i32 -> i32
    ```
  }];

  let arguments = (ins
    SPIRV_AnyPtr:$format,
    Variadic<SPIRV_Type>:$arguments
  );
  
   let results = (outs
    SPIRV_Integer:$result
  );

  let assemblyFormat = [{
   $format ( $arguments^ )? attr-dict `:`  type($format) ( `,` type($arguments)^ )? `->` type($result)
  }];

  let hasVerifier = 0;
}
#endif // MLIR_DIALECT_SPIRV_IR_CL_OPS