[CT] Updated CT X86 test for the LLVM 21 changes

clang/include/clang/Basic/Builtins.td

@@ -5253,3 +5253,11 @@ def CountedByRef : Builtin {
   let Attributes = [NoThrow, CustomTypeChecking];
   let Prototype = "int(...)";
 }
+
+// Constant-time select builtin
+def CtSelect : Builtin {
+  let Spellings = ["__builtin_ct_select"];
+  let Attributes = [NoThrow, UnevaluatedArguments,
+                    ConstIgnoringExceptions, CustomTypeChecking];
+  let Prototype = "void(...)";
+}

clang/lib/Basic/Targets/AArch64.cpp

@@ -872,6 +872,7 @@ bool AArch64TargetInfo::hasFeature(StringRef Feature) const {
       .Case("ssve-fp8fma", HasSSVE_FP8FMA)
       .Case("sme-f8f32", HasSME_F8F32)
       .Case("sme-f8f16", HasSME_F8F16)
+      .Case("ctselect", true)
       .Default(false);
 }
 

clang/lib/Basic/Targets/ARM.cpp

@@ -664,6 +664,7 @@ bool ARMTargetInfo::hasFeature(StringRef Feature) const {
       .Case("hwdiv", HWDiv & HWDivThumb)
       .Case("hwdiv-arm", HWDiv & HWDivARM)
       .Case("mve", hasMVE())
+      .Case("ctselect", true)
       .Default(false);
 }
 

clang/lib/Basic/Targets/X86.cpp

@@ -1298,6 +1298,7 @@ bool X86TargetInfo::hasFeature(StringRef Feature) const {
       .Case("cf", HasCF)
       .Case("zu", HasZU)
       .Case("branch-hint", HasBranchHint)
+      .Case("ctselect", true)
       .Default(false);
 }
 

clang/lib/CodeGen/CGBuiltin.cpp

@@ -26,6 +26,10 @@
 #include "TargetInfo.h"
 #include "clang/AST/OSLog.h"
 #include "clang/AST/StmtVisitor.h"
+#include "clang/AST/OperationKinds.h"
+#include "clang/AST/Type.h"
+#include "clang/Basic/DiagnosticSema.h"
+#include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "llvm/IR/InlineAsm.h"
@@ -6441,6 +6445,40 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     auto Str = CGM.GetAddrOfConstantCString(Name, "");
     return RValue::get(Str.getPointer());
   }
+  case Builtin::BI__builtin_ct_select: {
+    if (E->getNumArgs() != 3) {
+      CGM.getDiags().Report(E->getBeginLoc(),
+                            E->getNumArgs() > 3
+                                ? diag::err_typecheck_call_too_many_args
+                                : diag::err_typecheck_call_too_few_args);
+      return GetUndefRValue(E->getType());
+    }
+
+    auto *Cond = EmitScalarExpr(E->getArg(0));
+    auto *A = EmitScalarExpr(E->getArg(1));
+    auto *B = EmitScalarExpr(E->getArg(2));
+
+    // Verify types match
+    if (A->getType() != B->getType()) {
+      CGM.getDiags().Report(E->getBeginLoc(),
+                            diag::err_typecheck_convert_incompatible);
+      return GetUndefRValue(E->getType());
+    }
+
+    // Verify condition is integer type
+    if (!Cond->getType()->isIntegerTy()) {
+      CGM.getDiags().Report(E->getBeginLoc(), diag::err_typecheck_expect_int);
+      return GetUndefRValue(E->getType());
+    }
+
+    if (Cond->getType()->getIntegerBitWidth() != 1)
+      Cond = Builder.CreateICmpNE(
+          Cond, llvm::ConstantInt::get(Cond->getType(), 0), "cond.bool");
+
+    llvm::Function *Fn =
+        CGM.getIntrinsic(llvm::Intrinsic::ct_select, {A->getType()});
+    return RValue::get(Builder.CreateCall(Fn, {Cond, A, B}));
+  }
   }
 
   // If this is an alias for a lib function (e.g. __builtin_sin), emit

clang/lib/Sema/SemaChecking.cpp

@@ -3472,6 +3472,93 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
     if (BuiltinCountedByRef(TheCall))
       return ExprError();
     break;
+
+  case Builtin::BI__builtin_ct_select: {
+    if (TheCall->getNumArgs() != 3) {
+      // Simple argument count check without complex diagnostics
+      if (TheCall->getNumArgs() < 3) {
+        return Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
+               << 0 << 3 << TheCall->getNumArgs() << 0
+               << TheCall->getCallee()->getSourceRange();
+      } else {
+        return Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_many_args)
+               << 0 << 3 << TheCall->getNumArgs() << 0
+               << TheCall->getCallee()->getSourceRange();
+      }
+    }
+    auto *Cond = TheCall->getArg(0);
+    auto *A = TheCall->getArg(1);
+    auto *B = TheCall->getArg(2);
+
+    QualType CondTy = Cond->getType();
+    if (!CondTy->isIntegerType()) {
+      return Diag(Cond->getBeginLoc(), diag::err_typecheck_cond_expect_scalar)
+             << CondTy << Cond->getSourceRange();
+    }
+
+    QualType ATy = A->getType();
+    QualType BTy = B->getType();
+
+    // check for scalar or vector scalar type
+    if ((!ATy->isScalarType() && !ATy->isVectorType()) ||
+        (!BTy->isScalarType() && !BTy->isVectorType())) {
+      return Diag(A->getBeginLoc(),
+                  diag::err_typecheck_cond_incompatible_operands)
+             << ATy << BTy << A->getSourceRange() << B->getSourceRange();
+    }
+
+    // Check if both operands have the same type or can be implicitly converted
+    QualType ResultTy;
+    if (Context.hasSameType(ATy, BTy)) {
+      ResultTy = ATy;
+    } else {
+      // Try to find a common type using the same logic as conditional
+      // expressions
+      ExprResult ARes = ExprResult(A);
+      ExprResult BRes = ExprResult(B);
+
+      // For arithmetic types, allow promotions within the same category only
+      if (ATy->isArithmeticType() && BTy->isArithmeticType()) {
+        // Check if both are integer types or both are floating types
+        bool AIsInteger = ATy->isIntegerType();
+        bool BIsInteger = BTy->isIntegerType();
+        bool AIsFloating = ATy->isFloatingType();
+        bool BIsFloating = BTy->isFloatingType();
+
+        if ((AIsInteger && BIsInteger) || (AIsFloating && BIsFloating)) {
+          // Both are in the same category, allow usual arithmetic conversions
+          ResultTy = UsualArithmeticConversions(
+              ARes, BRes, TheCall->getBeginLoc(), ArithConvKind::Conditional);
+          if (ARes.isInvalid() || BRes.isInvalid() || ResultTy.isNull()) {
+            return Diag(A->getBeginLoc(),
+                        diag::err_typecheck_cond_incompatible_operands)
+                   << ATy << BTy << A->getSourceRange() << B->getSourceRange();
+          }
+          // Update the arguments with any necessary implicit casts
+          TheCall->setArg(1, ARes.get());
+          TheCall->setArg(2, BRes.get());
+        } else {
+          // Different categories (int vs float), not allowed
+          return Diag(A->getBeginLoc(),
+                      diag::err_typecheck_cond_incompatible_operands)
+                 << ATy << BTy << A->getSourceRange() << B->getSourceRange();
+        }
+      } else {
+        // For non-arithmetic types, they must be exactly the same
+        return Diag(A->getBeginLoc(),
+                    diag::err_typecheck_cond_incompatible_operands)
+               << ATy << BTy << A->getSourceRange() << B->getSourceRange();
+      }
+    }
+
+    ExprResult CondRes = PerformContextuallyConvertToBool(Cond);
+    if (CondRes.isInvalid())
+      return ExprError();
+
+    TheCall->setArg(0, CondRes.get());
+    TheCall->setType(ResultTy);
+    return TheCall;
+  } break;
   }
 
   if (getLangOpts().HLSL && HLSL().CheckBuiltinFunctionCall(BuiltinID, TheCall))