[mlir] Add CtPop to MathOps with lowering to LLVM

[rsuderman]

Summary

math.ctpop maths to the llvm.ctpop intrinsic.

[ftynse]

mlir/include/mlir/Dialect/Math/IR/MathOps.td

24

Nit: integer point -> integer.

301

Nit: CtPopOp

313

Nit: ctpop

314–315

How does it work for vectors?

316

"standard attributes" are no longer a thing.

[rsuderman]

Updated for ftynse comments

[jpienaar]

mlir/include/mlir/Dialect/Math/IR/MathOps.td

307

If using declarative ASM we generate the syntax already, so this would result in duplication I believe (like https://mlir.llvm.org/docs/Dialects/MathOps/#mathatan2-mlirmathatan2op)

314

That should already be captured in the argument constraints and displayed in table format so seems redundant here (im not actually seeing where it is verified though)

[rsuderman]

Updated for jpienaar comments.

mlir/include/mlir/Dialect/Math/IR/MathOps.td

 
 // Base class for math dialect ops. Ops in this dialect have no side effects and
 // can be applied element-wise to vectors and tensors.
 class Math_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Math_Dialect, mnemonic, traits # [NoSideEffect,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits>;
 
+// Base class for unary math operations on integer point types. Require a
+// operand and result of the same type. This type can be an integer type, or
+// vector or tensor thereof.
+class Math_IntegerUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+    Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
+  let arguments = (ins SignlessIntegerLike:$operand);
+  let results = (outs SignlessIntegerLike:$result);
+
+  let assemblyFormat = "$operand attr-dict `:` type($result)";
+}
+
 // Base class for unary math operations on floating point types. Require a
 // operand and result of the same type. This type can be a floating point type,
 // or vector or tensor thereof.
 class Math_FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
     Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
   let arguments = (ins FloatLike:$operand);
   let results = (outs FloatLike:$result);
 
let description = [{
 
     // Tensor element-wise sine value.
     %x = math.sin %y : tensor<4x?xf8>
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// CtOp
+//===----------------------------------------------------------------------===//
+
+def Math_CtPopOp : Math_IntegerUnaryOp<"ctpop"> {
+  let summary = "counts the number of set bits of an integer value";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `math.ctpop` ssa-use `:` type
+    ```
+
+    The `crpop` operation computes the number of set bits of an integer value.
+    This type may be an integer scalar type, a vector of integers, or a tensor
+    of integers.
+    It has no standard attributes.
+
+    Example:
+
+    ```mlir
+    // Scalar ctpop function value.
+    %a = math.ctpop %b : i32
+
+    // SIMD vector element-wise ctpop function value.
+    %f = math.ctpop %g : vector<4xi16>
+
+    // Tensor element-wise ctpop function value.
+    %x = math.ctpop %y : tensor<4x?xi8>
+    ```
+  }];
+}
+
+//===----------------------------------------------------------------------===//
 // ErfOp
 //===----------------------------------------------------------------------===//
 
 def Math_ErfOp : Math_FloatUnaryOp<"erf"> {
   let summary = "error function of the specified value";
   let description = [{
     Syntax:
 

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

 using namespace mlir;
 
 namespace {
 using AbsOpLowering = VectorConvertToLLVMPattern<math::AbsOp, LLVM::FAbsOp>;
 using CeilOpLowering = VectorConvertToLLVMPattern<math::CeilOp, LLVM::FCeilOp>;
 using CopySignOpLowering =
     VectorConvertToLLVMPattern<math::CopySignOp, LLVM::CopySignOp>;
 using CosOpLowering = VectorConvertToLLVMPattern<math::CosOp, LLVM::CosOp>;
+using CtPopFOpLowering =
+    VectorConvertToLLVMPattern<math::CtPopOp, LLVM::CtPopOp>;
 using ExpOpLowering = VectorConvertToLLVMPattern<math::ExpOp, LLVM::ExpOp>;
 using Exp2OpLowering = VectorConvertToLLVMPattern<math::Exp2Op, LLVM::Exp2Op>;
 using FloorOpLowering =
     VectorConvertToLLVMPattern<math::FloorOp, LLVM::FFloorOp>;
 using FmaOpLowering = VectorConvertToLLVMPattern<math::FmaOp, LLVM::FMAOp>;
 using Log10OpLowering =
     VectorConvertToLLVMPattern<math::Log10Op, LLVM::Log10Op>;
 using Log2OpLowering = VectorConvertToLLVMPattern<math::Log2Op, LLVM::Log2Op>;

 void mlir::populateMathToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                 RewritePatternSet &patterns) {
   // clang-format off
   patterns.add<
     AbsOpLowering,
     CeilOpLowering,
     CopySignOpLowering,
     CosOpLowering,
+    CtPopFOpLowering,
     ExpOpLowering,
     Exp2OpLowering,
     ExpM1OpLowering,
     FloorOpLowering,
     FmaOpLowering,
     Log10OpLowering,
     Log1pOpLowering,
     Log2OpLowering,

mlir/test/Conversion/MathToLLVM/math-to-llvm.mlir

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