initial

Author: mishaobu

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

@@ -1029,6 +1029,108 @@ def SPIRV_GLFMixOp :
   let hasVerifier = 0;
 }
 
+// -----
+
+def SPIRV_GLDistanceOp : SPIRV_GLOp<"Distance", 67, [Pure]> {
+  let summary = "Return distance between two points";
+
+  let description = [{
+    Result is the distance between x and y. This is |x - y|, where |x| is the 
+    length of x computed as sqrt(x * x).
+
+    The operands must all be vectors whose component type is floating-point.
+    Result Type must be a scalar floating-point type.
+
+    #### Example:
+
+    ```mlir
+    %2 = spirv.GL.Distance %0, %1 : vector<3xf32>, vector<3xf32> -> f32
+    ```
+  }];
+
+  let arguments = (ins
+    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$p0,
+    SPIRV_ScalarOrVectorOf<SPIRV_Float>:$p1
+  );
+
+  let results = (outs
+    SPIRV_Float:$result
+  );
+
+  let assemblyFormat = [{
+    operands attr-dict `:` type($p0) `,` type($p1) `->` type($result)
+  }];
+}
+
+// -----
+
+def SPIRV_GLCrossOp : SPIRV_GLBinaryArithmeticOp<"Cross", 68, SPIRV_Float> {
+  let summary = "Return the cross product of two 3-component vectors";
+
+  let description = [{
+    Result is the cross product of x and y, i.e. dot(x,y).
+
+    Arguments x and y must be vectors of size 3, of floating-point type.
+    Results are computed per component.
+    The result is a vector of the same type as the inputs.
+
+    #### Example:
+
+    ```mlir
+    %2 = spirv.GL.Cross %0, %1 : vector<3xf32>
+    %3 = spirv.GL.Cross %0, %1 : vector<3xf16>
+    ```
+  }];
+}
+
+// -----
+
+def SPIRV_GLNormalizeOp : SPIRV_GLUnaryArithmeticOp<"Normalize", 69, SPIRV_Float> {
+  let summary = "Normalizes a vector operand";
+
+  let description = [{
+    Result is the vector v/sqrt(dot(v,v)).
+    The result is undefined if dot(v,v) is less than or equal to 0.
+
+    The operand v must be a vector whose component type is floating-point.
+    The Result Type must be the same type as v.
+    Results are computed per component.
+
+    #### Example:
+
+    ```mlir
+    %2 = spirv.GL.Normalize %0 : vector<3xf32>
+    %3 = spirv.GL.Normalize %1 : vector<4xf16>
+    ```
+  }];
+}
+
+// -----
+
+def SPIRV_GLReflectOp : SPIRV_GLBinaryArithmeticOp<"Reflect", 71, SPIRV_Float> {
+  let summary = "Calculate reflection direction vector";
+
+  let description = [{
+    Result is the reflection direction vector: I - 2 * dot(N, I) * N, where I is 
+    the incident vector and N is the surface orientation vector.
+
+    N must be normalized to achieve the desired result.
+
+    The operands must all be a scalar or vector whose component type is floating-point.
+    Result Type and the type of all operands must be the same type. 
+    Results are computed per component.
+
+    #### Example:
+
+    ```mlir
+    %2 = spirv.GL.Reflect %0, %1 : f32
+    %3 = spirv.GL.Reflect %0, %1 : vector<3xf32>
+    ```
+  }];
+}
+
+// ----
+
 def SPIRV_GLFindUMsbOp : SPIRV_GLUnaryArithmeticOp<"FindUMsb", 75, SPIRV_Int32> {
   let summary = "Unsigned-integer most-significant bit";
 

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

@@ -2094,3 +2094,30 @@ LogicalResult spirv::VectorTimesScalarOp::verify() {
     return emitOpError("scalar operand and result element type match");
   return success();
 }
+
+//===----------------------------------------------------------------------===//
+// spirv.GLDistanceOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult spirv::GLDistanceOp::verify() {
+  auto p0Type = getP0().getType();
+  auto p1Type = getP1().getType();
+  auto resultType = getResult().getType();
+
+  auto p0VectorType = p0Type.dyn_cast<VectorType>();
+  auto p1VectorType = p1Type.dyn_cast<VectorType>();
+  if (!p0VectorType || !p1VectorType)
+    return emitOpError("operands must be vectors");
+
+  if (p0VectorType.getShape() != p1VectorType.getShape())
+    return emitOpError("operands must have same shape");
+
+  if (!resultType.isa<FloatType>())
+    return emitOpError("result must be scalar float");
+
+  if (p0VectorType.getElementType() != resultType || 
+      p1VectorType.getElementType() != resultType)
+    return emitOpError("operand vector elements must match result type");
+
+  return success();
+}