[mlir][StandardToLLVM] Add SinOp to LLVM dialect and lowering of std.sin to this op.

[ftynse]

Could we have a test?

[mravishankar]

In D79505#2023280, @ftynse wrote:

Could we have a test?

Tried to look for where to add test here. But couldnt find a test for say cos, , etc. Not sure what was the testing convention was. (I actually had a comment on the patch but as happens often, forgot to hit submit). I'll add a test anyway.

[nicolasvasilache]

How does this relate to how tanh evolved?
In the past there was an op for tanh but it was backpedaled on, I do not remember the rationale for removing it offhand but we def. want consistency between trig functions,

[mravishankar]

Adding tests

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 def LLVM_FMAOp : LLVM_TernarySameArgsIntrinsicOp<"fma">;
 def LLVM_FMulAddOp : LLVM_TernarySameArgsIntrinsicOp<"fmuladd">;
 def LLVM_Log10Op : LLVM_UnaryIntrinsicOp<"log10">;
 def LLVM_Log2Op : LLVM_UnaryIntrinsicOp<"log2">;
 def LLVM_LogOp : LLVM_UnaryIntrinsicOp<"log">;
 def LLVM_Prefetch : LLVM_ZeroResultIntrOp<"prefetch", [0]>,
                     Arguments<(ins LLVM_Type:$addr, LLVM_Type:$rw,
                                LLVM_Type:$hint, LLVM_Type:$cache)>;
+def LLVM_SinOp : LLVM_UnaryIntrinsicOp<"sin">;
 def LLVM_SqrtOp : LLVM_UnaryIntrinsicOp<"sqrt">;
 
 //
 // Vector Reductions.
 //
 
 def LLVM_experimental_vector_reduce_add : LLVM_VectorReduction<"add">;
 def LLVM_experimental_vector_reduce_and : LLVM_VectorReduction<"and">;

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 using ShiftLeftOpLowering =
     OneToOneConvertToLLVMPattern<ShiftLeftOp, LLVM::ShlOp>;
 using SignedDivIOpLowering =
     VectorConvertToLLVMPattern<SignedDivIOp, LLVM::SDivOp>;
 using SignedRemIOpLowering =
     VectorConvertToLLVMPattern<SignedRemIOp, LLVM::SRemOp>;
 using SignedShiftRightOpLowering =
     OneToOneConvertToLLVMPattern<SignedShiftRightOp, LLVM::AShrOp>;
+using SinOpLowering = VectorConvertToLLVMPattern<SinOp, LLVM::SinOp>;
 using SqrtOpLowering = VectorConvertToLLVMPattern<SqrtOp, LLVM::SqrtOp>;
 using SubFOpLowering = VectorConvertToLLVMPattern<SubFOp, LLVM::FSubOp>;
 using SubIOpLowering = VectorConvertToLLVMPattern<SubIOp, LLVM::SubOp>;
 using UnsignedDivIOpLowering =
     VectorConvertToLLVMPattern<UnsignedDivIOp, LLVM::UDivOp>;
 using UnsignedRemIOpLowering =
     VectorConvertToLLVMPattern<UnsignedRemIOp, LLVM::URemOp>;
 using UnsignedShiftRightOpLowering =
patterns.insert<
       RsqrtOpLowering,
       SIToFPLowering,
       SelectOpLowering,
       ShiftLeftOpLowering,
       SignExtendIOpLowering,
       SignedDivIOpLowering,
       SignedRemIOpLowering,
       SignedShiftRightOpLowering,
+      SinOpLowering,
       SplatOpLowering,
       SplatNdOpLowering,
       SqrtOpLowering,
       SubCFOpLowering,
       SubFOpLowering,
       SubIOpLowering,
       TruncateIOpLowering,
       UnsignedDivIOpLowering,

mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir

func @rsqrt(%arg0 : f32) {
   // CHECK: %[[SQRT:.*]] = "llvm.intr.sqrt"(%arg0) : (!llvm.float) -> !llvm.float
   // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : !llvm.float
   %0 = rsqrt %arg0 : f32
   std.return
 }
 
 // -----
 
+// CHECK-LABEL: func @sine(
+// CHECK-SAME: !llvm.float
+func @sine(%arg0 : f32) {
+  // CHECK: "llvm.intr.sin"(%arg0) : (!llvm.float) -> !llvm.float
+  %0 = sin %arg0 : f32
+  std.return
+}
+
+// -----
+
 // CHECK-LABEL: func @rsqrt_double(
 // CHECK-SAME: !llvm.double
 func @rsqrt_double(%arg0 : f64) {
   // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f64) : !llvm.double
   // CHECK: %[[SQRT:.*]] = "llvm.intr.sqrt"(%arg0) : (!llvm.double) -> !llvm.double
   // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] : !llvm.double
   %0 = rsqrt %arg0 : f64
   std.return

mlir/test/Dialect/LLVMIR/roundtrip.mlir

 // CHECK:       %27 = llvm.fpext %arg1 : !llvm.float to !llvm.x86_fp80
 // CHECK-NEXT:  %28 = llvm.fpext %arg1 : !llvm.float to !llvm.fp128
   %27 = llvm.fpext %arg1 : !llvm.float to !llvm.x86_fp80
   %28 = llvm.fpext %arg1 : !llvm.float to !llvm.fp128
 
 // CHECK:  %29 = llvm.fneg %arg1 : !llvm.float
   %29 = llvm.fneg %arg1 : !llvm.float
 
+// CHECK: "llvm.intr.sin"(%arg1) : (!llvm.float) -> !llvm.float
+  %30 = "llvm.intr.sin"(%arg1) : (!llvm.float) -> !llvm.float
+
 // CHECK:  llvm.return
   llvm.return
 }
 
 // An larger self-contained function.
 // CHECK-LABEL:func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
 func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
 // CHECK-NEXT:  %0 = llvm.mlir.constant(3 : i64) : !llvm.i32
func @useFenceInst() {
   // CHECK:  syncscope("agent") seq_cst 
   llvm.fence syncscope("agent") seq_cst
   // CHECK:  seq_cst 
   llvm.fence syncscope("") seq_cst
   // CHECK:  release
   llvm.fence release
   return
 }
 No newline at end of file