[CIR][CIRGen][builtin] handle __popcnt (#1479)

This PR removes a useless argument `convertToInt` and removes hardcoded
`Sint32Type`.

I realized I committed a new file with CRLF before. Really sorry about
that >_<

Author: FantasqueX

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -130,11 +130,11 @@ static mlir::Value emitBinaryMaybeConstrainedFPBuiltin(CIRGenFunction &CGF,
 template <typename Op>
 static RValue emitBuiltinBitOp(
     CIRGenFunction &CGF, const CallExpr *E,
-    std::optional<CIRGenFunction::BuiltinCheckKind> CK = std::nullopt,
-    bool isZeroPoison = false, bool convertToInt = true) {
+    std::optional<CIRGenFunction::BuiltinCheckKind> checkKind = std::nullopt,
+    bool isZeroPoison = false) {
   mlir::Value arg;
-  if (CK.has_value())
-    arg = CGF.emitCheckedArgForBuiltin(E->getArg(0), *CK);
+  if (checkKind.has_value())
+    arg = CGF.emitCheckedArgForBuiltin(E->getArg(0), *checkKind);
   else
     arg = CGF.emitScalarExpr(E->getArg(0));
 
@@ -146,12 +146,12 @@ static RValue emitBuiltinBitOp(
   } else {
     op = CGF.getBuilder().create<Op>(CGF.getLoc(E->getExprLoc()), arg);
   }
-  const mlir::Value bitResult = op.getResult();
-  if (const auto si32Ty = CGF.getBuilder().getSInt32Ty();
-      convertToInt && arg.getType() != si32Ty) {
-    return RValue::get(CGF.getBuilder().createIntCast(bitResult, si32Ty));
+  const mlir::Value result = op.getResult();
+  if (const mlir::Type resultType = CGF.convertType(E->getType());
+      op.getResult().getType() != resultType) {
+    return RValue::get(CGF.getBuilder().createIntCast(result, resultType));
   }
-  return RValue::get(bitResult);
+  return RValue::get(result);
 }
 
 // Initialize the alloca with the given size and alignment according to the lang
@@ -1098,8 +1098,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   case Builtin::BI__lzcnt16:
   case Builtin::BI__lzcnt:
   case Builtin::BI__lzcnt64: {
-    return emitBuiltinBitOp<cir::BitClzOp>(*this, E, BCK_CLZPassedZero, false,
-                                           false);
+    return emitBuiltinBitOp<cir::BitClzOp>(*this, E, BCK_CLZPassedZero, false);
   }
 
   case Builtin::BI__popcnt16:

clang/test/CIR/CodeGen/ms-intrinsics-other.c

@@ -1,31 +1,55 @@
-// RUN: %clang_cc1 -ffreestanding -fms-extensions -Wno-implicit-function-declaration -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
-// RUN: FileCheck %s --check-prefix=CIR --input-file=%t.cir
-// RUN: %clang_cc1 -ffreestanding -fms-extensions -Wno-implicit-function-declaration -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
-// RUN: FileCheck %s --check-prefix=LLVM --input-file=%t.ll
-
-unsigned short test__lzcnt16(unsigned short x) {
-  return __lzcnt16(x);
-}
-// CIR-LABEL: test__lzcnt16
-// CIR: {{%.*}} = cir.bit.clz({{%.*}} : !u16i) : !u16i
-
-// LLVM-LABEL: test__lzcnt16
-// LLVM: {{%.*}} = call i16 @llvm.ctlz.i16(i16 {{%.*}}, i1 false)
-
-unsigned int test__lzcnt(unsigned int x) {
-  return __lzcnt(x);
-}
-// CIR-LABEL: test__lzcnt
-// CIR: {{%.*}} = cir.bit.clz({{%.*}} : !u32i) : !u32i
-
-// LLVM-LABEL: test__lzcnt
-// LLVM:  {{%.*}} = call i32 @llvm.ctlz.i32(i32 {{%.*}}, i1 false)
-
-unsigned __int64 test__lzcnt64(unsigned __int64 x) {
-  return __lzcnt64(x);
-}
-// CIR-LABEL: test__lzcnt64
-// CIR: {{%.*}} = cir.bit.clz({{%.*}} : !u64i) : !u64i
-
-// LLVM-LABEL: test__lzcnt64
-// LLVM: {{%.*}} = call i64 @llvm.ctlz.i64(i64 {{%.*}}, i1 false)
+// RUN: %clang_cc1 -ffreestanding -fms-extensions -Wno-implicit-function-declaration -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck %s --check-prefix=CIR --input-file=%t.cir
+// RUN: %clang_cc1 -ffreestanding -fms-extensions -Wno-implicit-function-declaration -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck %s --check-prefix=LLVM --input-file=%t.ll
+
+// This test mimics clang/test/CodeGen/ms-intrinsics-other.c, which eventually
+// CIR shall be able to support fully.
+
+unsigned short test__lzcnt16(unsigned short x) {
+  return __lzcnt16(x);
+}
+// CIR-LABEL: test__lzcnt16
+// CIR: {{%.*}} = cir.bit.clz({{%.*}} : !u16i) : !u16i
+// LLVM-LABEL: test__lzcnt16
+// LLVM: {{%.*}} = call i16 @llvm.ctlz.i16(i16 {{%.*}}, i1 false)
+
+unsigned int test__lzcnt(unsigned int x) {
+  return __lzcnt(x);
+}
+// CIR-LABEL: test__lzcnt
+// CIR: {{%.*}} = cir.bit.clz({{%.*}} : !u32i) : !u32i
+// LLVM-LABEL: test__lzcnt
+// LLVM:  {{%.*}} = call i32 @llvm.ctlz.i32(i32 {{%.*}}, i1 false)
+
+unsigned __int64 test__lzcnt64(unsigned __int64 x) {
+  return __lzcnt64(x);
+}
+// CIR-LABEL: test__lzcnt64
+// CIR: {{%.*}} = cir.bit.clz({{%.*}} : !u64i) : !u64i
+// LLVM-LABEL: test__lzcnt64
+// LLVM: {{%.*}} = call i64 @llvm.ctlz.i64(i64 {{%.*}}, i1 false)
+
+unsigned short test__popcnt16(unsigned short x) {
+  return __popcnt16(x);
+}
+// CIR-LABEL: test__popcnt16
+// CIR: {{%.*}} = cir.bit.popcount({{%.*}} : !u16i) : !u16i
+// LLVM-LABEL: test__popcnt16
+// LLVM: {{%.*}} = call i16 @llvm.ctpop.i16(i16 {{%.*}})
+
+unsigned int test__popcnt(unsigned int x) {
+  return __popcnt(x);
+}
+// CIR-LABEL: test__popcnt
+// CIR: {{%.*}} = cir.bit.popcount({{%.*}} : !u32i) : !u32i
+// LLVM-LABEL: test__popcnt
+// LLVM: {{%.*}} = call i32 @llvm.ctpop.i32(i32 {{%.*}})
+
+unsigned __int64 test__popcnt64(unsigned __int64 x) {
+  return __popcnt64(x);
+}
+// CIR-LABEL: test__popcnt64
+// CIR: {{%.*}} = cir.bit.popcount({{%.*}} : !u64i) : !u64i
+// LLVM-LABEL: test__popcnt64
+// LLVM: {{%.*}} = call i64 @llvm.ctpop.i64(i64 {{%.*}})