[clang] 411a53e - [CIR] Upstream Builtin Exp2Op (#169152)

[via cfe-commits]

Author: Letu Ren
Date: 2025-11-26T09:49:59-08:00
New Revision: 411a53e16fbc9bfe23fd887c918c3ec5d74fa2bc

URL: https://github.com/llvm/llvm-project/commit/411a53e16fbc9bfe23fd887c918c3ec5d74fa2bc
DIFF: https://github.com/llvm/llvm-project/commit/411a53e16fbc9bfe23fd887c918c3ec5d74fa2bc.diff

LOG: [CIR] Upstream Builtin Exp2Op (#169152)

Add the cir::exp2 operation and handling for the related builtins.

Added: 
    

Modified: 
    clang/include/clang/CIR/Dialect/IR/CIROps.td
    clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
    clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
    clang/test/CIR/CodeGen/builtins-floating-point.c

Removed: 
    


################################################################################
diff  --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index a19c4f951fff9..777b49434f119 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -4612,6 +4612,16 @@ def CIR_ExpOp : CIR_UnaryFPToFPBuiltinOp<"exp", "ExpOp"> {
   }];
 }
 
+def CIR_Exp2Op : CIR_UnaryFPToFPBuiltinOp<"exp2", "Exp2Op"> {
+  let summary = "Computes the floating-point base-2 exponential value";
+  let description = [{
+    `cir.exp2` computes the base-2 exponential of a floating-point operand and
+     returns a result of the same type.
+
+    Floating-point exceptions are ignored, and it does not set `errno`.
+  }];
+}
+
 def CIR_FAbsOp : CIR_UnaryFPToFPBuiltinOp<"fabs", "FAbsOp"> {
   let summary = "Computes the floating-point absolute value";
   let description = [{

diff  --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
index 4f0fe918e778f..7d4d13121d5e5 100644
--- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
@@ -300,6 +300,17 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl &gd, unsigned builtinID,
     assert(!cir::MissingFeatures::fastMathFlags());
     return emitUnaryMaybeConstrainedFPBuiltin<cir::ExpOp>(*this, *e);
 
+  case Builtin::BIexp2:
+  case Builtin::BIexp2f:
+  case Builtin::BIexp2l:
+  case Builtin::BI__builtin_exp2:
+  case Builtin::BI__builtin_exp2f:
+  case Builtin::BI__builtin_exp2f16:
+  case Builtin::BI__builtin_exp2l:
+  case Builtin::BI__builtin_exp2f128:
+    assert(!cir::MissingFeatures::fastMathFlags());
+    return emitUnaryMaybeConstrainedFPBuiltin<cir::Exp2Op>(*this, *e);
+
   case Builtin::BIfabs:
   case Builtin::BIfabsf:
   case Builtin::BIfabsl:

diff  --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
index 6136d48204e0c..cd923a15af132 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -202,6 +202,14 @@ mlir::LogicalResult CIRToLLVMExpOpLowering::matchAndRewrite(
   return mlir::success();
 }
 
+mlir::LogicalResult CIRToLLVMExp2OpLowering::matchAndRewrite(
+    cir::Exp2Op op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  mlir::Type resTy = typeConverter->convertType(op.getType());
+  rewriter.replaceOpWithNewOp<mlir::LLVM::Exp2Op>(op, resTy, adaptor.getSrc());
+  return mlir::success();
+}
+
 static mlir::Value getLLVMIntCast(mlir::ConversionPatternRewriter &rewriter,
                                   mlir::Value llvmSrc, mlir::Type llvmDstIntTy,
                                   bool isUnsigned, uint64_t cirSrcWidth,

diff  --git a/clang/test/CIR/CodeGen/builtins-floating-point.c b/clang/test/CIR/CodeGen/builtins-floating-point.c
index 1b7de650662c7..a4307c57b04b6 100644
--- a/clang/test/CIR/CodeGen/builtins-floating-point.c
+++ b/clang/test/CIR/CodeGen/builtins-floating-point.c
@@ -46,3 +46,24 @@ long double expl(long double f) {
   // LLVM: %{{.*}} = call fp128 @llvm.exp.f128(fp128 %{{.*}})
   // OGCG: %{{.*}} = call fp128 @llvm.exp.f128(fp128 %{{.*}})
 }
+
+float exp2f(float f) {
+  return __builtin_exp2f(f);
+  // CIR: %{{.*}} = cir.exp2 {{.*}} : !cir.float
+  // LLVM: %{{.*}} = call float @llvm.exp2.f32(float %{{.*}})
+  // OGCG: %{{.*}} = call float @llvm.exp2.f32(float %{{.*}})
+}
+
+double my_exp2(double f) {
+  return __builtin_exp2(f);
+  // CIR: %{{.*}} = cir.exp2 {{.*}} : !cir.double
+  // LLVM: %{{.*}} = call double @llvm.exp2.f64(double %{{.*}})
+  // OGCG: %{{.*}} = call double @llvm.exp2.f64(double %{{.*}})
+}
+
+long double my_exp2l(long double f) {
+  return __builtin_exp2l(f);
+  // CIR: %{{.*}} = cir.exp2 {{.*}} : !cir.long_double<!cir.f128>
+  // LLVM: %{{.*}} = call fp128 @llvm.exp2.f128(fp128 %{{.*}})
+  // OGCG: %{{.*}} = call fp128 @llvm.exp2.f128(fp128 %{{.*}})
+}