Rename CIR bit operations to cir.bit.*

Author: Lancern

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -993,35 +993,167 @@ def CmpOp : CIR_Op<"cmp", [Pure, SameTypeOperands]> {
 // BitsOp
 //===----------------------------------------------------------------------===//
 
-def BitsOpKind_CLRSB : I32EnumAttrCase<"clrsb", 1>;
-def BitsOpKind_CTZ : I32EnumAttrCase<"ctz", 2>;
-def BitsOpKind_CLZ : I32EnumAttrCase<"clz", 3>;
-def BitsOpKind_FFS : I32EnumAttrCase<"ffs", 4>;
-def BitsOpKind_PARITY : I32EnumAttrCase<"parity", 5>;
-def BitsOpKind_POPCOUNT : I32EnumAttrCase<"popcount", 6>;
-
-def BitsOpKind : I32EnumAttr<
-    "BitsOpKind", "bits op kind", [
-        BitsOpKind_CLRSB, BitsOpKind_CTZ, BitsOpKind_CLZ, BitsOpKind_FFS,
-        BitsOpKind_PARITY, BitsOpKind_POPCOUNT,
-    ]> {
-  let cppNamespace = "::mlir::cir";
+class CIR_BitOp<string mnemonic> : CIR_Op<mnemonic, [Pure]> {
+  let arguments = (ins CIR_IntType:$input);
+  let results = (outs CIR_IntType:$result);
+
+  let assemblyFormat = [{
+    `(` $input `:` type($input) `)` `:` type($result) attr-dict
+  }];
 }
 
-def BitsOp : CIR_Op<"bits", [Pure]> {
-  let summary = "Perform bit operations on the input integer";
+def BitClrsbOp : CIR_BitOp<"bit.clrsb"> {
+  let summary = "Get the number of leading redundant sign bits in the input";
   let description = [{
-    `cir.bits` performs bit-level operations on the input integral operand.
-    All supported operations include `clrsb`, `ctz`, `clz`, `ffs`, `parity`,
-    and `popcount`.
+    Compute the number of leading redundant sign bits in the input integer.
+
+    The input integer must be a signed integer. The most significant bit of the
+    input integer is the sign bit. The `cir.bit.clrsb` operation returns the
+    number of redundant sign bits in the input, that is, the number of bits
+    following the most significant bit that are identical to it.
+
+    Examples:
+
+    ```mlir
+    !s32i = !cir.int<s, 32>
+
+    // %0 = 0xDEADBEEF, 0b1101_1110_1010_1101_1011_1110_1110_1111
+    %0 = cir.const(#cir.int<3735928559> : !s32i) : !s32i
+    // %1 will be 1 because there is 1 bit following the most significant bit
+    // that is identical to it.
+    %1 = cir.bit.clrsb(%0 : !s32i) : !s32i
+
+    // %2 = 1, 0b0000_0000_0000_0000_0000_0000_0000_0001
+    %2 = cir.const(#cir.int<1> : !s32i) : !s32i
+    // %3 will be 30
+    %3 = cir.bit.clrsb(%2 : !s32i) : !s32i
+    ```
   }];
 
-  let results = (outs CIR_IntType:$result);
-  let arguments = (ins Arg<BitsOpKind, "op kind">:$kind,
-                       CIR_IntType:$input);
+  let hasVerifier = 1;
+}
 
-  let assemblyFormat = [{
-    `(` $kind `,` $input `:` type($input) `)` `:` type($result) attr-dict
+def BitCtzOp : CIR_BitOp<"bit.ctz"> {
+  let summary = "Get the number of trailing 0-bits in the input";
+  let description = [{
+    Compute the number of trailing 0-bits in the input.
+
+    The input integer must be an unsigned integer. The `cir.bit.ctz` operation
+    returns the number of consecutive 0-bits at the least significant bit
+    position in the input.
+
+    This operation invokes undefined behavior if the input value is 0.
+
+    Example:
+
+    ```mlir
+    !s32i = !cir.int<s, 32>
+    !u32i = !cir.int<u, 32>
+
+    // %0 = 0b1000
+    %0 = cir.const(#cir.int<8> : !u32i) : !u32i
+    // %1 will be 3
+    %1 = cir.bit.ctz(%0 : !u32i) : !s32i
+    ```
+  }];
+
+  let hasVerifier = 1;
+}
+
+def BitClzOp : CIR_BitOp<"bit.clz"> {
+  let summary = "Get the number of leading 0-bits in the input";
+  let description = [{
+    Compute the number of leading 0-bits in the input.
+
+    The input integer must be an unsigned integer. The `cir.bit.clz` operation
+    returns the number of consecutive 0-bits at the most significant bit
+    position in the input.
+
+    This operation invokes undefined behavior if the input value is 0.
+
+    Example:
+
+    ```mlir
+    !s32i = !cir.int<s, 32>
+    !u32i = !cir.int<u, 32>
+
+    // %0 = 0b0000_0000_0000_0000_0000_0000_0000_1000
+    %0 = cir.const(#cir.int<8> : !u32i) : !u32i
+    // %1 will be 28
+    %1 = cir.bit.clz(%0 : !u32i) : !s32i
+    ```
+  }];
+
+  let hasVerifier = 1;
+}
+
+def BitFfsOp : CIR_BitOp<"bit.ffs"> {
+  let summary = "Get the position of the least significant 1-bit of input";
+  let description = [{
+    Compute the position of the least significant 1-bit of the input.
+
+    The input integer must be a signed integer. The `cir.bit.ffs` operation
+    returns one plus the index of the least significant 1-bit of the input
+    signed integer. As a special case, if the input integer is 0, `cir.bit.ffs`
+    returns 0.
+
+    Example:
+
+    ```mlir
+    !s32i = !cir.int<s, 32>
+
+    // %0 = 0x0010_1000
+    %0 = cir.const(#cir.int<40> : !s32i) : !s32i
+    // #1 will be 4 since the 4th least significant bit is 1.
+    %1 = cir.bit.ffs(%0 : !s32i) : !s32i
+    ```
+  }];
+
+  let hasVerifier = 1;
+}
+
+def BitParityOp : CIR_BitOp<"bit.parity"> {
+  let summary = "Get the parity of input";
+  let description = [{
+    Compute the parity of the input. The parity of an integer is the number of
+    1-bits in it modulo 2.
+
+    The input must be an unsigned integer.
+
+    Example:
+
+    ```mlir
+    !s32i = !cir.int<s, 32>
+    !u32i = !cir.int<u, 32>
+
+    // %0 = 0x0110_1000
+    %0 = cir.const(#cir.int<104> : !u32i) : !s32i
+    // %1 will be 1 since there are 3 1-bits in %0
+    %1 = cir.bit.parity(%0 : !u32i) : !s32i
+    ```
+  }];
+
+  let hasVerifier = 1;
+}
+
+def BitPopcountOp : CIR_BitOp<"bit.popcount"> {
+  let summary = "Get the number of 1-bits in input";
+  let description = [{
+    Compute the number of 1-bits in the input.
+
+    The input must be an unsigned integer.
+
+    Example:
+
+    ```mlir
+    !s32i = !cir.int<s, 32>
+    !u32i = !cir.int<u, 32>
+
+    // %0 = 0x0110_1000
+    %0 = cir.const(#cir.int<104> : !u32i) : !s32i
+    // %1 will be 3 since there are 3 1-bits in %0
+    %1 = cir.bit.popcount(%0 : !u32i) : !s32i
+    ```
   }];
 
   let hasVerifier = 1;

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -55,19 +55,19 @@ static RValue buildUnaryFPBuiltin(CIRGenFunction &CGF, const CallExpr &E) {
   return RValue::get(Call->getResult(0));
 }
 
+template <typename Op>
 static RValue
-buildBuiltinBitsOp(CIRGenFunction &CGF, const CallExpr *E,
-                   mlir::cir::BitsOpKind Kind,
-                   std::optional<CIRGenFunction::BuiltinCheckKind> CK) {
+buildBuiltinBitOp(CIRGenFunction &CGF, const CallExpr *E,
+                  std::optional<CIRGenFunction::BuiltinCheckKind> CK) {
   mlir::Value arg;
   if (CK.has_value())
     arg = CGF.buildCheckedArgForBuiltin(E->getArg(0), *CK);
   else
     arg = CGF.buildScalarExpr(E->getArg(0));
 
   auto resultTy = CGF.ConvertType(E->getType());
-  auto op = CGF.getBuilder().create<mlir::cir::BitsOp>(
-      CGF.getLoc(E->getExprLoc()), resultTy, Kind, arg);
+  auto op =
+      CGF.getBuilder().create<Op>(CGF.getLoc(E->getExprLoc()), resultTy, arg);
   return RValue::get(op);
 }
 
@@ -499,43 +499,37 @@ RValue CIRGenFunction::buildBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   case Builtin::BI__builtin_clrsb:
   case Builtin::BI__builtin_clrsbl:
   case Builtin::BI__builtin_clrsbll:
-    return buildBuiltinBitsOp(*this, E, mlir::cir::BitsOpKind::clrsb,
-                              std::nullopt);
+    return buildBuiltinBitOp<mlir::cir::BitClrsbOp>(*this, E, std::nullopt);
 
   case Builtin::BI__builtin_ctzs:
   case Builtin::BI__builtin_ctz:
   case Builtin::BI__builtin_ctzl:
   case Builtin::BI__builtin_ctzll:
-    return buildBuiltinBitsOp(*this, E, mlir::cir::BitsOpKind::ctz,
-                              BCK_CTZPassedZero);
+    return buildBuiltinBitOp<mlir::cir::BitCtzOp>(*this, E, BCK_CTZPassedZero);
 
   case Builtin::BI__builtin_clzs:
   case Builtin::BI__builtin_clz:
   case Builtin::BI__builtin_clzl:
   case Builtin::BI__builtin_clzll:
-    return buildBuiltinBitsOp(*this, E, mlir::cir::BitsOpKind::clz,
-                              BCK_CLZPassedZero);
+    return buildBuiltinBitOp<mlir::cir::BitClzOp>(*this, E, BCK_CLZPassedZero);
 
   case Builtin::BI__builtin_ffs:
   case Builtin::BI__builtin_ffsl:
   case Builtin::BI__builtin_ffsll:
-    return buildBuiltinBitsOp(*this, E, mlir::cir::BitsOpKind::ffs,
-                              std::nullopt);
+    return buildBuiltinBitOp<mlir::cir::BitFfsOp>(*this, E, std::nullopt);
 
   case Builtin::BI__builtin_parity:
   case Builtin::BI__builtin_parityl:
   case Builtin::BI__builtin_parityll:
-    return buildBuiltinBitsOp(*this, E, mlir::cir::BitsOpKind::parity,
-                              std::nullopt);
+    return buildBuiltinBitOp<mlir::cir::BitParityOp>(*this, E, std::nullopt);
 
   case Builtin::BI__popcnt16:
   case Builtin::BI__popcnt:
   case Builtin::BI__popcnt64:
   case Builtin::BI__builtin_popcount:
   case Builtin::BI__builtin_popcountl:
   case Builtin::BI__builtin_popcountll:
-    return buildBuiltinBitsOp(*this, E, mlir::cir::BitsOpKind::popcount,
-                              std::nullopt);
+    return buildBuiltinBitOp<mlir::cir::BitPopcountOp>(*this, E, std::nullopt);
   }
 
   // If this is an alias for a lib function (e.g. __builtin_sin), emit

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -844,61 +844,57 @@ Block *BrCondOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
 }
 
 //===----------------------------------------------------------------------===//
-// BitsOp
+// CIR_BitOp family of operations
 //===----------------------------------------------------------------------===//
 
-LogicalResult BitsOp::verify() {
-  auto inputTy = getInput().getType();
-  auto inputIsSigned = inputTy.getIsSigned();
-  auto inputWidth = inputTy.getWidth();
-
-  switch (getKind()) {
-  case mlir::cir::BitsOpKind::clrsb:
-  case mlir::cir::BitsOpKind::ffs:
-    // Input to clrsb and ffs must be signed integer of width 32 and 64.
-    if (!inputIsSigned) {
-      return emitOpError(
-          "input value to clrsb or ffs must be a signed integer");
-    }
-    if (inputWidth != 32 && inputWidth != 64) {
-      return emitOpError(
-          "input value to clrsb or ffs must be a 32-bit or 64-bit integer");
-    }
-    break;
+LogicalResult BitClrsbOp::verify() {
+  if (!getInput().getType().isSigned())
+    return emitOpError("input of cir.bit.clrsb must be a signed integer");
+  if (!getType().isSigned() || getType().getWidth() != 32)
+    return emitOpError(
+        "result of cir.bit.clrsb must be a 32-bit signed integer");
+  return success();
+}
 
-  case mlir::cir::BitsOpKind::clz:
-  case mlir::cir::BitsOpKind::ctz:
-  case mlir::cir::BitsOpKind::popcount:
-    if (inputIsSigned) {
-      return emitOpError("input value to clz, ctz, parity, or popcount must be "
-                         "an unsigned integer");
-    }
-    if (inputWidth != 16 && inputWidth != 32 && inputWidth != 64) {
-      return emitOpError("input value to clz, ctz, parity, or popcount must be "
-                         "either a 16-bit, a 32-bit, or a 64-bit integer");
-    }
-    break;
+LogicalResult BitClzOp::verify() {
+  if (!getInput().getType().isUnsigned())
+    return emitOpError("input of cir.bit.clz must be an unsigned integer");
+  if (!getType().isSigned() || getType().getWidth() != 32)
+    return emitOpError("result of cir.bit.clz must be a 32-bit signed integer");
+  return success();
+}
 
-  case mlir::cir::BitsOpKind::parity:
-    if (inputIsSigned) {
-      return emitOpError("input value to parity must be an unsigned integer");
-    }
-    if (inputWidth != 32 && inputWidth != 64) {
-      return emitOpError(
-          "input value to parity must be a 32-bit or 64-bit integer");
-    }
-    break;
+LogicalResult BitCtzOp::verify() {
+  if (!getInput().getType().isUnsigned())
+    return emitOpError("input of cir.bit.ctz must be an unsigned integer");
+  if (!getType().isSigned() || getType().getWidth() != 32)
+    return emitOpError("result of cir.bit.ctz must be a 32-bit signed integer");
+  return success();
+}
 
-  default:
-    llvm_unreachable("unknown bits operation kind");
-  }
+LogicalResult BitFfsOp::verify() {
+  if (!getInput().getType().isSigned())
+    return emitOpError("input of cir.bit.ffs must be a signed integer");
+  if (!getType().isSigned() || getType().getWidth() != 32)
+    return emitOpError("result of cir.bit.ffs must be a 32-bit signed integer");
+  return success();
+}
 
-  auto resultTy = getType();
-  // TODO: how should we deal with targets whose `int` is not `int32_t`?
-  if (!resultTy.getIsSigned() || resultTy.getWidth() != 32) {
-    return emitOpError("result of cir.bits must be a 32-bit signed integer");
-  }
+LogicalResult BitParityOp::verify() {
+  if (!getInput().getType().isUnsigned())
+    return emitOpError("input of cir.bit.parity must be an unsigned integer");
+  if (!getType().isSigned() || getType().getWidth() != 32)
+    return emitOpError(
+        "result of cir.bit.parity must be a 32-bit signed integer");
+  return success();
+}
 
+LogicalResult BitPopcountOp::verify() {
+  if (!getInput().getType().isUnsigned())
+    return emitOpError("input of cir.bit.popcount must be an unsigned integer");
+  if (!getType().isSigned() || getType().getWidth() != 32)
+    return emitOpError(
+        "result of cir.bit.popcount must be a 32-bit signed integer");
   return success();
 }