[mlir] Add sine operation to Standard dialect.

[mravishankar]

Summary

Also add lowering of sine operation to SPIR-V dialect.

[rriddle]

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

1241

Please keep these in alphabetical order

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

let description = [{
     %f = cos %g : vector<4xf32>
 
     // Tensor element-wise cosine value.
     %x = cos %y : tensor<4x?xf8>
     ```
   }];
 }
 
+def SinOp : FloatUnaryOp<"sin"> {
+  let summary = "sine of the specified value";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `std.sin` ssa-use `:` type
+    ```
+
+    The `sin` operation computes the sine of a given value. It takes one
+    operand and returns one result of the same type. This type may be a float
+    scalar type, a vector whose element type is float, or a tensor of floats.
+    It has no standard attributes.
+
+    Example:
+
+    ```mlir
+    // Scalar sine value.
+    %a = sin %b : f64
+
+    // SIMD vector element-wise sine value.
+    %f = sin %g : vector<4xf32>
+
+    // Tensor element-wise sine value.
+    %x = sin %y : tensor<4x?xf8>
+    ```
+  }];
+}
+
+
 //===----------------------------------------------------------------------===//
 // DeallocOp
 //===----------------------------------------------------------------------===//
 
 def DeallocOp : Std_Op<"dealloc", [MemoryEffects<[MemFree]>]> {
   let summary = "memory deallocation operation";
   let description = [{
     The `dealloc` operation frees the region of memory referenced by a memref

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

patterns.insert<
       UnaryAndBinaryOpPattern<NegFOp, spirv::FNegateOp>,
       UnaryAndBinaryOpPattern<RemFOp, spirv::FRemOp>,
       UnaryAndBinaryOpPattern<RsqrtOp, spirv::GLSLInverseSqrtOp>,
       UnaryAndBinaryOpPattern<ShiftLeftOp, spirv::ShiftLeftLogicalOp>,
       UnaryAndBinaryOpPattern<SignedDivIOp, spirv::SDivOp>,
       UnaryAndBinaryOpPattern<SignedRemIOp, spirv::SRemOp>,
       UnaryAndBinaryOpPattern<SignedShiftRightOp,
                               spirv::ShiftRightArithmeticOp>,
+      UnaryAndBinaryOpPattern<SinOp, spirv::GLSLSinOp>,
       UnaryAndBinaryOpPattern<SqrtOp, spirv::GLSLSqrtOp>,
       UnaryAndBinaryOpPattern<SubFOp, spirv::FSubOp>,
       UnaryAndBinaryOpPattern<SubIOp, spirv::ISubOp>,
       UnaryAndBinaryOpPattern<TanhOp, spirv::GLSLTanhOp>,
       UnaryAndBinaryOpPattern<UnsignedDivIOp, spirv::UDivOp>,
       UnaryAndBinaryOpPattern<UnsignedRemIOp, spirv::UModOp>,
       UnaryAndBinaryOpPattern<UnsignedShiftRightOp, spirv::ShiftRightLogicalOp>,
       BitwiseOpPattern<AndOp, spirv::LogicalAndOp, spirv::BitwiseAndOp>,

mlir/test/Conversion/StandardToSPIRV/std-ops-to-spirv.mlir

func @float32_unary_scalar(%arg0: f32) {
   // CHECK: spv.FNegate %{{.*}}: f32
   %5 = negf %arg0 : f32
   // CHECK: spv.GLSL.InverseSqrt %{{.*}}: f32
   %6 = rsqrt %arg0 : f32
   // CHECK: spv.GLSL.Sqrt %{{.*}}: f32
   %7 = sqrt %arg0 : f32
   // CHECK: spv.GLSL.Tanh %{{.*}}: f32
   %8 = tanh %arg0 : f32
+  // CHECK: spv.GLSL.Sin %{{.*}}: f32
+  %9 = sin %arg0 : f32
   return
 }
 
 // Check float binary operation conversions.
 // CHECK-LABEL: @float32_binary_scalar
 func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
   // CHECK: spv.FAdd %{{.*}}, %{{.*}}: f32
   %0 = addf %lhs, %rhs: f32

mlir/test/IR/core-ops.mlir

^bb42(%t: tensor<4x4x?xf32>, %f: f32, %i: i32, %idx : index, %j: i64, %half: f16):
   %143 = fpext %vcf32 : vector<4xf32> to vector<4xf64>
 
   // CHECK: = fptrunc {{.*}} : vector<4xf32> to vector<4xf16>
   %144 = fptrunc %vcf32 : vector<4xf32> to vector<4xf16>
 
   // CHECK: %{{[0-9]+}} = rsqrt %arg1 : f32
   %145 = rsqrt %f : f32
 
+  // CHECK: %{{[0-9]+}} = sin %arg1 : f32
+  %146 = "std.sin"(%f) : (f32) -> f32
+
+  // CHECK: %{{[0-9]+}} = sin %arg1 : f32
+  %147 = sin %f : f32
+
+  // CHECK: %{{[0-9]+}} = sin %cst_8 : vector<4xf32>
+  %148 = sin %vcf32 : vector<4xf32>
+
+  // CHECK: %{{[0-9]+}} = sin %arg0 : tensor<4x4x?xf32>
+  %149 = sin %t : tensor<4x4x?xf32>
+
   return
 }
 
 // CHECK-LABEL: func @affine_apply() {
 func @affine_apply() {
   %i = "std.constant"() {value = 0: index} : () -> index
   %j = "std.constant"() {value = 1: index} : () -> index