[mlir][Pass] Add support for lowering unary std ops to SPIR-V.

[mravishankar]

Nice!

[rriddle]

Drive by comment: The [Pass] tag generally refers to the general pass manager infrastructure(i.e. the Pass/ directory), so it doesn't really make sense for this revision. Something like [StandardToSPIRV] would have been more appropriate.

[antiagainst]

In D76661#1938448, @rriddle wrote:

Drive by comment: The [Pass] tag generally refers to the general pass manager infrastructure(i.e. the Pass/ directory), so it doesn't really make sense for this revision. Something like [StandardToSPIRV] would have been more appropriate.

I'll revise this before landing.

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

 //===----------------------------------------------------------------------===//
 
 // Note that DRR cannot be used for the patterns in this file: we may need to
 // convert type along the way, which requires ConversionPattern. DRR generates
 // normal RewritePattern.
 
 namespace {
 
-/// Converts binary standard operations to SPIR-V operations.
+/// Converts unary and binary standard operations to SPIR-V operations.
 template <typename StdOp, typename SPIRVOp>
-class BinaryOpPattern final : public SPIRVOpLowering<StdOp> {
+class UnaryAndBinaryOpPattern final : public SPIRVOpLowering<StdOp> {
 public:
   using SPIRVOpLowering<StdOp>::SPIRVOpLowering;
 
   LogicalResult
   matchAndRewrite(StdOp operation, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    assert(operands.size() == 2);
+    assert(operands.size() <= 2);
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
     rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType, operands,
                                                   ArrayRef<NamedAttribute>());
     return success();
   }
 };

 // Pattern population
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 void populateStandardToSPIRVPatterns(MLIRContext *context,
                                      SPIRVTypeConverter &typeConverter,
                                      OwningRewritePatternList &patterns) {
   patterns.insert<
-      BinaryOpPattern<AddFOp, spirv::FAddOp>,
-      BinaryOpPattern<AddIOp, spirv::IAddOp>,
-      BinaryOpPattern<DivFOp, spirv::FDivOp>,
-      BinaryOpPattern<MulFOp, spirv::FMulOp>,
-      BinaryOpPattern<MulIOp, spirv::IMulOp>,
-      BinaryOpPattern<RemFOp, spirv::FRemOp>,
-      BinaryOpPattern<ShiftLeftOp, spirv::ShiftLeftLogicalOp>,
-      BinaryOpPattern<SignedShiftRightOp, spirv::ShiftRightArithmeticOp>,
-      BinaryOpPattern<SignedDivIOp, spirv::SDivOp>,
-      BinaryOpPattern<SignedRemIOp, spirv::SRemOp>,
-      BinaryOpPattern<SubFOp, spirv::FSubOp>,
-      BinaryOpPattern<SubIOp, spirv::ISubOp>,
-      BinaryOpPattern<UnsignedDivIOp, spirv::UDivOp>,
-      BinaryOpPattern<UnsignedRemIOp, spirv::UModOp>,
-      BinaryOpPattern<UnsignedShiftRightOp, spirv::ShiftRightLogicalOp>,
+      UnaryAndBinaryOpPattern<AbsFOp, spirv::GLSLFAbsOp>,
+      UnaryAndBinaryOpPattern<AddFOp, spirv::FAddOp>,
+      UnaryAndBinaryOpPattern<AddIOp, spirv::IAddOp>,
+      UnaryAndBinaryOpPattern<CeilFOp, spirv::GLSLCeilOp>,
+      UnaryAndBinaryOpPattern<CosOp, spirv::GLSLCosOp>,
+      UnaryAndBinaryOpPattern<DivFOp, spirv::FDivOp>,
+      UnaryAndBinaryOpPattern<ExpOp, spirv::GLSLExpOp>,
+      UnaryAndBinaryOpPattern<LogOp, spirv::GLSLLogOp>,
+      UnaryAndBinaryOpPattern<MulFOp, spirv::FMulOp>,
+      UnaryAndBinaryOpPattern<MulIOp, spirv::IMulOp>,
+      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<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>,
       BitwiseOpPattern<OrOp, spirv::LogicalOrOp, spirv::BitwiseOrOp>,
       ConstantCompositeOpPattern, ConstantScalarOpPattern, CmpFOpPattern,
       CmpIOpPattern, LoadOpPattern, ReturnOpPattern, SelectOpPattern,
       StoreOpPattern, TypeCastingOpPattern<SIToFPOp, spirv::ConvertSToFOp>,
       TypeCastingOpPattern<FPExtOp, spirv::FConvertOp>,
       TypeCastingOpPattern<FPTruncOp, spirv::FConvertOp>, XOrOpPattern>(
       context, typeConverter);
 }
 } // namespace mlir

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

func @int32_scalar(%lhs: i32, %rhs: i32) {
   %4 = remi_signed %lhs, %rhs: i32
   // CHECK: spv.UDiv %{{.*}}, %{{.*}}: i32
   %5 = divi_unsigned %lhs, %rhs: i32
   // CHECK: spv.UMod %{{.*}}, %{{.*}}: i32
   %6 = remi_unsigned %lhs, %rhs: i32
   return
 }
 
-// Check float operation conversions.
-// CHECK-LABEL: @float32_scalar
-func @float32_scalar(%lhs: f32, %rhs: f32) {
+// Check float unary operation conversions.
+// CHECK-LABEL: @float32_unary_scalar
+func @float32_unary_scalar(%arg0: f32) {
+  // CHECK: spv.GLSL.FAbs %{{.*}}: f32
+  %0 = absf %arg0 : f32
+  // CHECK: spv.GLSL.Ceil %{{.*}}: f32
+  %1 = ceilf %arg0 : f32
+  // CHECK: spv.GLSL.Cos %{{.*}}: f32
+  %2 = cos %arg0 : f32
+  // CHECK: spv.GLSL.Exp %{{.*}}: f32
+  %3 = exp %arg0 : f32
+  // CHECK: spv.GLSL.Log %{{.*}}: f32
+  %4 = log %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
+  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
   // CHECK: spv.FSub %{{.*}}, %{{.*}}: f32
   %1 = subf %lhs, %rhs: f32
   // CHECK: spv.FMul %{{.*}}, %{{.*}}: f32
   %2 = mulf %lhs, %rhs: f32
   // CHECK: spv.FDiv %{{.*}}, %{{.*}}: f32
   %3 = divf %lhs, %rhs: f32