[Mlir-commits] [mlir] 4376f8c - [mlir][spirv][nfc] Sort CL ops (#72868)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Mon Nov 20 09:26:33 PST 2023
Author: Ivan Butygin
Date: 2023-11-20T20:26:28+03:00
New Revision: 4376f8c949a95914856199941ebed18c8c27b5cc
URL: https://github.com/llvm/llvm-project/commit/4376f8c949a95914856199941ebed18c8c27b5cc
DIFF: https://github.com/llvm/llvm-project/commit/4376f8c949a95914856199941ebed18c8c27b5cc.diff
LOG: [mlir][spirv][nfc] Sort CL ops (#72868)
Extracted from https://github.com/llvm/llvm-project/pull/72800
Added:
Modified:
mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td
Removed:
################################################################################
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td
index 66ed2db681196b1..c4900fb79f346f3 100644
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td
@@ -268,127 +268,127 @@ def SPIRV_CLFAbsOp : SPIRV_CLUnaryArithmeticOp<"fabs", 23, SPIRV_Float> {
// -----
-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.
- }];
+def SPIRV_CLFMaxOp : SPIRV_CLBinaryArithmeticOp<"fmax", 27, SPIRV_Float> {
+ let summary = "Return maximum of two floating-point operands";
let description = [{
- Result Type and x must be floating-point or vector(2,3,4,8,16) of
- floating-point values.
+ 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.
- All of the operands, including the Result Type operand, must be of the
- same type.
+ Result Type, x and y must be floating-point or vector(2,3,4,8,16)
+ of floating-point values.
- <!-- End of AutoGen section -->
+ All of the operands, including the Result Type operand,
+ must be of the same type.
+ <!-- End of AutoGen section -->
```
float-scalar-vector-type ::= float-type |
`vector<` integer-literal `x` float-type `>`
- floor-op ::= ssa-id `=` `spirv.CL.floor` ssa-use `:`
- float-scalar-vector-type
+ fmax-op ::= ssa-id `=` `spirv.CL.fmax` ssa-use `:`
+ float-scalar-vector-type
```
-
#### Example:
```mlir
- %2 = spirv.CL.floor %0 : f32
- %3 = spirv.CL.ceifloorl %1 : vector<3xf16>
+ %2 = spirv.CL.fmax %0, %1 : f32
+ %3 = spirv.CL.fmax %0, %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.
- }];
+def SPIRV_CLFMinOp : SPIRV_CLBinaryArithmeticOp<"fmin", 28, SPIRV_Float> {
+ let summary = "Return minimum of two floating-point operands";
let description = [{
- Result Type, a, b and c must be floating-point or vector(2,3,4,8,16) of
- floating-point values.
+ 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.
- All of the operands, including the Result Type operand, must be of the
- same type.
+ 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.
- <!-- End of AutoGen section -->
+ <!-- End of AutoGen section -->
```
- fma-op ::= ssa-id `=` `spirv.CL.fma` ssa-use, ssa-use, ssa-use `:`
- float-scalar-vector-type
+ float-scalar-vector-type ::= float-type |
+ `vector<` integer-literal `x` float-type `>`
+ fmin-op ::= ssa-id `=` `spirv.CL.fmin` ssa-use `:`
+ float-scalar-vector-type
```
-
#### Example:
```mlir
- %0 = spirv.CL.fma %a, %b, %c : f32
- %1 = spirv.CL.fma %a, %b, %c : vector<3xf16>
+ %2 = spirv.CL.fmin %0, %1 : f32
+ %3 = spirv.CL.fmin %0, %1 : vector<3xf16>
```
}];
}
// -----
-def SPIRV_CLFMaxOp : SPIRV_CLBinaryArithmeticOp<"fmax", 27, SPIRV_Float> {
- let summary = "Return maximum of two floating-point operands";
+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 = [{
- 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.
+ 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.
+ All of the operands, including the Result Type operand, must be of the
+ same type.
<!-- End of AutoGen section -->
+
```
float-scalar-vector-type ::= float-type |
`vector<` integer-literal `x` float-type `>`
- fmax-op ::= ssa-id `=` `spirv.CL.fmax` ssa-use `:`
- float-scalar-vector-type
+ floor-op ::= ssa-id `=` `spirv.CL.floor` ssa-use `:`
+ float-scalar-vector-type
```
+
#### Example:
```mlir
- %2 = spirv.CL.fmax %0, %1 : f32
- %3 = spirv.CL.fmax %0, %1 : vector<3xf16>
+ %2 = spirv.CL.floor %0 : f32
+ %3 = spirv.CL.ceifloorl %1 : vector<3xf16>
```
}];
}
// -----
-def SPIRV_CLFMinOp : SPIRV_CLBinaryArithmeticOp<"fmin", 28, SPIRV_Float> {
- let summary = "Return minimum of two floating-point operands";
+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 = [{
- 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.
+ 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.
<!-- End of AutoGen section -->
+
```
- float-scalar-vector-type ::= float-type |
- `vector<` integer-literal `x` float-type `>`
- fmin-op ::= ssa-id `=` `spirv.CL.fmin` ssa-use `:`
- float-scalar-vector-type
+ fma-op ::= ssa-id `=` `spirv.CL.fma` ssa-use, ssa-use, ssa-use `:`
+ float-scalar-vector-type
```
+
#### Example:
```mlir
- %2 = spirv.CL.fmin %0, %1 : f32
- %3 = spirv.CL.fmin %0, %1 : vector<3xf16>
+ %0 = spirv.CL.fma %a, %b, %c : f32
+ %1 = spirv.CL.fma %a, %b, %c : vector<3xf16>
```
}];
}
@@ -456,10 +456,10 @@ def SPIRV_CLPowOp : SPIRV_CLBinaryArithmeticOp<"pow", 48, SPIRV_Float> {
// -----
-def SPIRV_CLRoundOp : SPIRV_CLUnaryArithmeticOp<"round", 55, SPIRV_Float> {
+def SPIRV_CLRintOp : SPIRV_CLUnaryArithmeticOp<"rint", 53, SPIRV_Float> {
let summary = [{
- Return the integral value nearest to x rounding halfway cases away from
- zero, regardless of the current rounding direction.
+ Round x to integral value (using round to nearest even rounding mode) in
+ floating-point format.
}];
let description = [{
@@ -474,24 +474,25 @@ def SPIRV_CLRoundOp : SPIRV_CLUnaryArithmeticOp<"round", 55, SPIRV_Float> {
```
float-scalar-vector-type ::= float-type |
`vector<` integer-literal `x` float-type `>`
- round-op ::= ssa-id `=` `spirv.CL.round` ssa-use `:`
+ rint-op ::= ssa-id `=` `spirv.CL.rint` ssa-use `:`
float-scalar-vector-type
```
+
#### Example:
```mlir
- %2 = spirv.CL.round %0 : f32
- %3 = spirv.CL.round %0 : vector<3xf16>
+ %0 = spirv.CL.rint %0 : f32
+ %1 = spirv.CL.rint %1 : vector<3xf16>
```
}];
}
// -----
-def SPIRV_CLRintOp : SPIRV_CLUnaryArithmeticOp<"rint", 53, SPIRV_Float> {
+def SPIRV_CLRoundOp : SPIRV_CLUnaryArithmeticOp<"round", 55, SPIRV_Float> {
let summary = [{
- Round x to integral value (using round to nearest even rounding mode) in
- floating-point format.
+ Return the integral value nearest to x rounding halfway cases away from
+ zero, regardless of the current rounding direction.
}];
let description = [{
@@ -506,15 +507,14 @@ def SPIRV_CLRintOp : SPIRV_CLUnaryArithmeticOp<"rint", 53, SPIRV_Float> {
```
float-scalar-vector-type ::= float-type |
`vector<` integer-literal `x` float-type `>`
- rint-op ::= ssa-id `=` `spirv.CL.rint` ssa-use `:`
+ round-op ::= ssa-id `=` `spirv.CL.round` ssa-use `:`
float-scalar-vector-type
```
-
#### Example:
```mlir
- %0 = spirv.CL.rint %0 : f32
- %1 = spirv.CL.rint %1 : vector<3xf16>
+ %2 = spirv.CL.round %0 : f32
+ %3 = spirv.CL.round %0 : vector<3xf16>
```
}];
}
@@ -551,6 +551,90 @@ def SPIRV_CLRsqrtOp : SPIRV_CLUnaryArithmeticOp<"rsqrt", 56, SPIRV_Float> {
// -----
+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.
+
+ <!-- End of AutoGen section -->
+ ```
+ integer-scalar-vector-type ::= integer-type |
+ `vector<` integer-literal `x` integer-type `>`
+ abs-op ::= ssa-id `=` `spirv.CL.s_abs` ssa-use `:`
+ integer-scalar-vector-type
+ ```
+ #### Example:
+
+ ```mlir
+ %2 = spirv.CL.s_abs %0 : i32
+ %3 = spirv.CL.s_abs %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.
+
+ <!-- End of AutoGen section -->
+ ```
+ integer-scalar-vector-type ::= integer-type |
+ `vector<` integer-literal `x` integer-type `>`
+ smax-op ::= ssa-id `=` `spirv.CL.s_max` ssa-use `:`
+ integer-scalar-vector-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.
+
+ <!-- End of AutoGen section -->
+ ```
+ integer-scalar-vector-type ::= integer-type |
+ `vector<` integer-literal `x` integer-type `>`
+ smin-op ::= ssa-id `=` `spirv.CL.s_min` ssa-use `:`
+ integer-scalar-vector-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.";
@@ -641,63 +725,6 @@ def SPIRV_CLTanhOp : SPIRV_CLUnaryArithmeticOp<"tanh", 63, SPIRV_Float> {
// -----
-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.
-
- <!-- End of AutoGen section -->
- ```
- integer-scalar-vector-type ::= integer-type |
- `vector<` integer-literal `x` integer-type `>`
- abs-op ::= ssa-id `=` `spirv.CL.s_abs` ssa-use `:`
- integer-scalar-vector-type
- ```
- #### Example:
-
- ```mlir
- %2 = spirv.CL.s_abs %0 : i32
- %3 = spirv.CL.s_abs %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.
-
- <!-- End of AutoGen section -->
- ```
- integer-scalar-vector-type ::= integer-type |
- `vector<` integer-literal `x` integer-type `>`
- smax-op ::= ssa-id `=` `spirv.CL.s_max` ssa-use `:`
- integer-scalar-vector-type
- ```
- #### Example:
- ```mlir
- %2 = spirv.CL.s_max %0, %1 : i32
- %3 = spirv.CL.s_max %0, %1 : vector<3xi16>
- ```
- }];
-}
-
-// -----
-
def SPIRV_CLUMaxOp : SPIRV_CLBinaryArithmeticOp<"u_max", 157, SPIRV_Integer> {
let summary = "Return maximum of two unsigned integer operands";
@@ -725,33 +752,6 @@ def SPIRV_CLUMaxOp : SPIRV_CLBinaryArithmeticOp<"u_max", 157, SPIRV_Integer> {
// -----
-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.
-
- <!-- End of AutoGen section -->
- ```
- integer-scalar-vector-type ::= integer-type |
- `vector<` integer-literal `x` integer-type `>`
- smin-op ::= ssa-id `=` `spirv.CL.s_min` ssa-use `:`
- integer-scalar-vector-type
- ```
- #### Example:
- ```mlir
- %2 = spirv.CL.s_min %0, %1 : i32
- %3 = spirv.CL.s_min %0, %1 : vector<3xi16>
- ```
- }];
-}
-
-// -----
-
def SPIRV_CLUMinOp : SPIRV_CLBinaryArithmeticOp<"u_min", 159, SPIRV_Integer> {
let summary = "Return minimum of two unsigned integer operands";
More information about the Mlir-commits
mailing list