[CIR][CIRGen] support builtin signbit

Author: PikachuHyA

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -417,6 +417,11 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return create<mlir::cir::MemCpyOp>(loc, dst, src, len);
   }
 
+  mlir::cir::SignBitOp createSignBit(mlir::Location loc, mlir::Value val) {
+    auto resTy = mlir::cir::IntType::get(getContext(), 32, true);
+    return create<mlir::cir::SignBitOp>(loc, resTy, val);
+  }
+
   mlir::Value createSub(mlir::Value lhs, mlir::Value rhs, bool hasNUW = false,
                         bool hasNSW = false) {
     auto op = create<mlir::cir::BinOp>(lhs.getLoc(), lhs.getType(),

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

@@ -5095,4 +5095,17 @@ def AtomicCmpXchg : CIR_Op<"atomic.cmp_xchg",
   let hasVerifier = 0;
 }
 
+def SignBitOp : CIR_Op<"signbit", [Pure]> {
+  let summary = "Checks the sign of a floating-point number";
+  let description = [{
+    It returns a non-zero value (true) if the number is negative
+    and zero (false) if the number is positive or zero.
+  }];
+  let arguments = (ins CIR_AnyFloat:$input);
+  let results = (outs SInt32:$res);
+  let assemblyFormat = [{
+      $input attr-dict `:` type($input) `->` qualified(type($res))
+  }];
+}
+
 #endif // LLVM_CLANG_CIR_DIALECT_IR_CIROPS

clang/include/clang/CIR/MissingFeatures.h

@@ -228,6 +228,7 @@ struct MissingFeatures {
   static bool xray() { return false; }
   static bool buildConstrainedFPCall() { return false; }
   static bool emitEmptyRecordCheck() { return false; }
+  static bool isPPC_FP128Ty() { return false; }
 
   // Inline assembly
   static bool asmGoto() { return false; }

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -217,6 +217,13 @@ static mlir::Value buildFromInt(CIRGenFunction &CGF, mlir::Value v, QualType t,
   return v;
 }
 
+static mlir::Value buildSignBit(mlir::Location loc, CIRGenFunction &CGF,
+                                mlir::Value val) {
+  assert(!::cir::MissingFeatures::isPPC_FP128Ty());
+  auto ret = CGF.getBuilder().createSignBit(loc, val);
+  return ret->getResult(0);
+}
+
 static Address checkAtomicAlignment(CIRGenFunction &CGF, const CallExpr *E) {
   ASTContext &ctx = CGF.getContext();
   Address ptr = CGF.buildPointerWithAlignment(E->getArg(0));
@@ -1707,8 +1714,12 @@ RValue CIRGenFunction::buildBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
 
   case Builtin::BI__builtin_signbit:
   case Builtin::BI__builtin_signbitf:
-  case Builtin::BI__builtin_signbitl:
-    llvm_unreachable("BI__builtin_signbit like NYI");
+  case Builtin::BI__builtin_signbitl: {
+    auto loc = getLoc(E->getBeginLoc());
+    return RValue::get(builder.createZExtOrBitCast(
+        loc, buildSignBit(loc, *this, buildScalarExpr(E->getArg(0))),
+        ConvertType(E->getType())));
+  }
 
   case Builtin::BI__warn_memset_zero_len:
     llvm_unreachable("BI__warn_memset_zero_len NYI");

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -4336,6 +4336,31 @@ class CIRAbsOpLowering : public mlir::OpConversionPattern<mlir::cir::AbsOp> {
     return mlir::success();
   }
 };
+class CIRSignBitOpLowering
+    : public mlir::OpConversionPattern<mlir::cir::SignBitOp> {
+public:
+  using OpConversionPattern<mlir::cir::SignBitOp>::OpConversionPattern;
+
+  mlir::LogicalResult
+  matchAndRewrite(mlir::cir::SignBitOp op, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    assert(!::cir::MissingFeatures::isPPC_FP128Ty());
+
+    mlir::DataLayout layout(op->getParentOfType<mlir::ModuleOp>());
+    int width = layout.getTypeSizeInBits(op.getInput().getType());
+    auto intTy = mlir::IntegerType::get(rewriter.getContext(), width);
+    auto bitcast = rewriter.create<mlir::LLVM::BitcastOp>(op->getLoc(), intTy,
+                                                          adaptor.getInput());
+    auto zero = rewriter.create<mlir::LLVM::ConstantOp>(op->getLoc(), intTy, 0);
+    auto cmpResult = rewriter.create<mlir::LLVM::ICmpOp>(
+        op.getLoc(), mlir::LLVM::ICmpPredicate::slt, bitcast.getResult(), zero);
+    auto converted = rewriter.create<mlir::LLVM::ZExtOp>(
+        op.getLoc(), mlir::IntegerType::get(rewriter.getContext(), 32),
+        cmpResult);
+    rewriter.replaceOp(op, converted);
+    return mlir::success();
+  }
+};
 
 void populateCIRToLLVMConversionPatterns(
     mlir::RewritePatternSet &patterns, mlir::TypeConverter &converter,
@@ -4377,7 +4402,7 @@ void populateCIRToLLVMConversionPatterns(
       CIRAssumeLowering, CIRAssumeAlignedLowering, CIRAssumeSepStorageLowering,
       CIRBaseClassAddrOpLowering, CIRDerivedClassAddrOpLowering,
       CIRVTTAddrPointOpLowering, CIRIsFPClassOpLowering, CIRAbsOpLowering,
-      CIRMemMoveOpLowering, CIRMemsetOpLowering
+      CIRMemMoveOpLowering, CIRMemsetOpLowering, CIRSignBitOpLowering
 #define GET_BUILTIN_LOWERING_LIST
 #include "clang/CIR/Dialect/IR/CIRBuiltinsLowering.inc"
 #undef GET_BUILTIN_LOWERING_LIST

clang/test/CIR/CodeGen/builtin-signbit.c

@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
+
+void test_signbit_float(float val) {
+    // CIR: test_signbit_float
+    // LLVM: test_signbit_float
+    __builtin_signbit(val);
+    // CIR: %{{.+}} = cir.signbit %{{.+}} : !cir.float -> !s32i
+    // LLVM: [[TMP1:%.*]] = bitcast float %{{.+}} to i32
+    // LLVM: [[TMP2:%.*]] = icmp slt i32 [[TMP1]], 0
+    // LLVM: %{{.+}} = zext i1 [[TMP2]] to i32
+}
+
+void test_signbit_double(double val) {
+    // CIR: test_signbit_double
+    // LLVM: test_signbit_double
+    __builtin_signbitf(val);
+    // CIR: %{{.+}} = cir.signbit %{{.+}} : !cir.float -> !s32i
+    // LLVM: [[CONV:%.*]] = fptrunc double %{{.+}} to float
+    // LLVM: [[TMP1:%.*]] = bitcast float [[CONV]] to i32
+    // LLVM: [[TMP2:%.*]] = icmp slt i32 [[TMP1]], 0
+    // LLVM: %{{.+}} = zext i1 [[TMP2]] to i32
+}
+void test_signbit_long_double(long double val) {
+    // CIR: test_signbit_long_double
+    // LLVM: test_signbit_long_double
+    __builtin_signbitl(val);
+    // CIR: %{{.+}} = cir.signbit %{{.+}} : !cir.long_double<!cir.f80> -> !s32i
+    // LLVM: [[TMP1:%.*]] = bitcast x86_fp80 %{{.+}} to i80
+    // LLVM: [[TMP2:%.*]] = icmp slt i80 [[TMP1]], 0
+    // LLVM: %{{.+}} = zext i1 [[TMP2]] to i32
+}