[Clang] Add elementwise min/max builtins.

[fhahn]

Summary

This patch implements builtin_elementwise_max and
builtin_elementwise_min, as specified in D111529.

[fhahn]

polish tests a bit

[fhahn]

Move type checking to helper function checkMathBuiltinElementType to be reused in D111986.

[fhahn]

ping :)

[aaron.ballman]

clang/include/clang/Sema/Sema.h

12715–12716

<nothing to fix>Why oh why did we start slapping Sema as a prefix on a bunch of functions implemented in a class named Sema?</nothing to fix>

clang/lib/Sema/SemaChecking.cpp

1981

Spurious whitespace change?

16659–16660

Sema typically comes first, so this is just to match local style.

16661

I'm a bit surprised we'd need !Ty->getAs<VectorType>() as I would have expected !ConstantMatrixType::isValidElementType(Ty) to cover all the type checking of Ty. Can you explain why the extra check is needed here?

16669

Do we actually need this parameter?

16673–16678

Should these arguments undergo usual conversions (array to pointer decay, integer promotions, etc)?

clang/test/Sema/builtins-elementwise-math.c

20–21

Also:

i = __builtin_elementwise_max(i, i, i); // too many arguments

42

Additional tests I would like to see:

int i;
short s;

__builtin_elementwise_min(i, s); // ok (integer promotions)?

enum e { one, two };
__builtin_elementwise_min(one, two); // ok (using enums)?

enum f { three };
__builtin_elementwise_min(one, three); // ok (different enums)?

_ExtInt(32) ext;
__builtin_elementwise_min(ext, ext); // ok (using bit-precise integers)?

const int ci;
__builtin_elementwise_min(i, ci); // ok (qualifiers don't match)?

[fhahn]

Thanks for taking a look!

clang/lib/Sema/SemaChecking.cpp

16659–16660

Thanks, adjusted!

16661

The builtins as implemented accept either vector types or a scalar type, which then must be a valid element type for matrix types. The second check may be a bit confusing, but the restrictions laid out in the spec for scalar/element-types match the matrix element type restrictions, so this seems a convenient helper to use.

Does this in general make sense?

16669

No, it can just return ExprResult(TheCall) instead I think!

16673–16678

I intentionally went with not performing conversions, because it might lead to surprising results. If the arguments have different types, it is not clear to me which type should be chosen to try convert the other one; e.g. if we have __builtin_elementwise_max(float, int) should the first argument be converted to int` or the second one to float?

Forcing the types to match without conversion seem to make them less error-prone to use, but I might be missing some general rule to handle type conflicts here?

clang/test/Sema/builtins-elementwise-math.c

20–21

I'll add it

42

Thanks I'll add those!

at the moment __builtin_elementwise_min(i, s); // ok (integer promotions)? would be rejected, as per my response in Sema.

The other currently are not handled properly, which I'll fix!

[aaron.ballman]

clang/lib/Sema/SemaChecking.cpp

16661

Thanks for the explanation, that makes sense.

16669

Could also return a bool and have the caller fiddle with ExprResult, too. I don't have strong opinions on which way to go though.

16673–16678

I'm not certain how these builtins are expected to be used, but if they're likely to be used with literals, I think we may want integer promotions because of that alone.

Btw, given that these only have two arguments, it seems like we could use the usual arithmetic conversions to pick a common type the same way as happens for binary operators.

If you end up not adding any conversions here, we should have a test case to cover passing in two array objects (which won't decay to pointers).

clang/test/Sema/builtins-elementwise-math.c

42

I'd still like to see the test case added so it's clear we intend to reject it. It may also be wise to add a test case involving an integer literal and a short variable cast to int to make it clear that you have to add casts sometimes to make this work.

Another interesting test is where sugars don't match. e.g.,

int i;
__attribute__((address_space(0))) int addr_space_i;
typedef int foo;

__builtin_elementwise_min(i, addr_space_i); // ok (attributes don't match)?
__builtin_elementwise_min(i, foo); // ok (sugar doesn't match)?

[aaron.ballman]

clang/test/Sema/builtins-elementwise-math.c

42

You might also need to handle something like:

int (i);
int j;
__builtin_elementwise_min(i, j);  // May get a type mismatch here

So you may need to do some type canonicalization to avoid these sorts of issues.

[fhahn]

clang/lib/Sema/SemaChecking.cpp

16673–16678

I'm not certain how these builtins are expected to be used, but if they're likely to be used with literals, I think we may want integer promotions because of that alone.

Yes, they should ideally work with literals! I think it should be relatively straight-forward to add promotion of literals.

Btw, given that these only have two arguments, it seems like we could use the usual arithmetic conversions to pick a common type the same way as happens for binary operators.

IIUC this happens in SemaOverload.cpp, but I am not sure how builtins would hook into the infrastructure there. Are there other builtins that are similarly overloaded by any chance?

[aaron.ballman]

clang/lib/Sema/SemaChecking.cpp

16673–16678

Yes, they should ideally work with literals! I think it should be relatively straight-forward to add promotion of literals.

I was thinking of the literal being an int and the variable being a short, so the literal isn't what needs promotion in that case. That said, I suppose character literals in C++ would promote from char to int, so there are some literals that could promote. That'd be a somewhat amusing test case for C and C++ both (__builtin_elementwise_max('a', 1);).

IUC this happens in SemaOverload.cpp, but I am not sure how builtins would hook into the infrastructure there. Are there other builtins that are similarly overloaded by any chance?

Sema::SemaBuiltinUnorderedCompare() uses this, for example:

ExprResult OrigArg0 = TheCall->getArg(0);
ExprResult OrigArg1 = TheCall->getArg(1);

// Do standard promotions between the two arguments, returning their common
// type.
QualType Res = UsualArithmeticConversions(
    OrigArg0, OrigArg1, TheCall->getExprLoc(), ACK_Comparison);
if (OrigArg0.isInvalid() || OrigArg1.isInvalid())
  return true;

[fhahn]

Address comments @aaron.ballman, thanks!

The most notable changes are using UsualArithmeticConversions for argument conversion and checking the canonical types. Also added a bunch of additional Sema tests as suggested, and some codegen tests for a couple of conversions.

[fhahn]

clang/lib/Sema/SemaChecking.cpp

16669

updated to return a bool

16673–16678

hat'd be a somewhat amusing test case for C and C++ both (__builtin_elementwise_max('a', 1);).

I added i1 = __builtin_elementwise_max(1, 'a'); to the codegen tests.

Sema::SemaBuiltinUnorderedCompare() uses this, for example:

Thanks a lot! I updated to code to use UsualArithmeticConversions and added the tests you suggested (hope I didn't miss any important ones). Looks like all should work as expected now.

clang/test/Sema/builtins-elementwise-math.c

42

Thanks, I updated the code to check the canonical type.

[aaron.ballman]

clang/lib/Sema/SemaChecking.cpp

16694

I think you want to set this to Res, because that's the common type between TyB and TyA, right? That will also ensure that qualifiers are stripped, I believe. e.g.,

const int a = 2;
int b = 1;
static_assert(!std::is_const_v<decltype(__builtin_elementwise_max(a, b))>);
static_assert(!std::is_const_v<decltype(__builtin_elementwise_max(b, a))>);

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8750–8751

Does err_typecheck_call_different_arg_types suffice?

8753–8754

It'd be nice to avoid this entirely as the diagnostic situation is one we would have elsewhere (so we should be able to use common diagnostic checking code from here and places like SemaBuiltinMatrixColumnMajorLoad() ideally).

clang/lib/Sema/SemaChecking.cpp

16661–16666

Related to the comment above on the diagnostic, I'm wondering if we want to abstract this into a helper function that gets used by all the elementwise builtins you're adding?

[aaron.ballman]

I thought of another test case -- should these new functions work on complex types? (Those are weird enough we may want to consider adding both Sema and CodeGen tests if we do support them, and Sema tests alone if we don't.)

[fhahn]

Address latest comments, thanks

• Added a generic err_builtin_invalid_arg_type diagnostic kind, which can also be used for some of the matrix type mismatches (see D112532).
• Dropped err_elementwise_math_arg_types_mismatch in favor of the existing err_typecheck_call_different_arg_types.
• Use Res to set the call type
• Add tests with _Complex, which gets rejected.
• add C++ test that check constness of builtins.

In D111985#3087057, @aaron.ballman wrote:

I thought of another test case -- should these new functions work on complex types? (Those are weird enough we may want to consider adding both Sema and CodeGen tests if we do support them, and Sema tests alone if we don't.)

At the moment they should not work with complex types (like C99's _Complex). The problem there is that there is no dedicated IR type and the LLVM intrinsics do not support complex types. So at the moment we cannot lower such operations effectively.

I think it would make sense to extend them to complex types once we can better model those operations in LLVM IR.

[fhahn]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8750–8751

err_typecheck_call_different_arg_types is sufficient, thanks!

8753–8754

I turned the diagnostic kind into a more generic one and also put up a patch to use them instead some of the custom matrix diagnostic kinds (D112532). WDYT?

I'm not sure if there's much potential for sharing the checking code, as it looks like most places check for slightly different things (or the check is quite compact already).

clang/lib/Sema/SemaChecking.cpp

16661–16666

Unfortunately I am not sure which code this is referring to. The element type check is already a generic function to be used to check the new builtins with 1 arg and the reduction builtins.

16694

Agreed, using TyB is confusing, so I updated it. I *think* it was still doing the right thing, because TyB is to B's type after conversion, so I *think* that would be to common type already.

I also added a .cpp Sema test file to check the constness.

[aaron.ballman]

LGTM, thank you!

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_debugtrap, "v", "n")
 BUILTIN(__builtin_unreachable, "v", "nr")
 BUILTIN(__builtin_shufflevector, "v."   , "nct")
 BUILTIN(__builtin_convertvector, "v."   , "nct")
 BUILTIN(__builtin_alloca, "v*z"   , "Fn")
 BUILTIN(__builtin_alloca_with_align, "v*zIz", "Fn")
 BUILTIN(__builtin_call_with_static_chain, "v.", "nt")
 
+BUILTIN(__builtin_elementwise_max, "v.", "nct")
+BUILTIN(__builtin_elementwise_min, "v.", "nct")
+
 BUILTIN(__builtin_matrix_transpose, "v.", "nFt")
 BUILTIN(__builtin_matrix_column_major_load, "v.", "nFt")
 BUILTIN(__builtin_matrix_column_major_store, "v.", "nFt")
 
 // "Overloaded" Atomic operator builtins.  These are overloaded to support data
 // types of i8, i16, i32, i64, and i128.  The front-end sees calls to the
 // non-suffixed version of these (which has a bogus type) and transforms them to
 // the right overloaded version in Sema (plus casts).

clang/include/clang/Basic/DiagnosticSemaKinds.td

 }
 
   def error_inoutput_conflict_with_clobber : Error<
     "asm-specifier for input or output variable conflicts with asm"
     " clobber list">;
 
 let CategoryName = "Semantic Issue" in {
 
+def err_elementwise_math_arg_types_mismatch : Error <
+  "argument types do not match, %0 != %1">;
+
+def err_elementwise_math_invalid_arg_type: Error <
+  "argument type %0 is not supported">;
+
 def err_invalid_conversion_between_matrixes : Error<
   "conversion between matrix types%diff{ $ and $|}0,1 of different size is not allowed">;
 
 def err_invalid_conversion_between_matrix_and_type : Error<
   "conversion between matrix type %0 and incompatible type %1 is not allowed">;
 
 def err_invalid_conversion_between_vectors : Error<
   "invalid conversion between vector type%diff{ $ and $|}0,1 of different "

clang/include/clang/Sema/Sema.h

bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
                                 int ArgNum, unsigned ExpectedFieldNum,
                                 bool AllowName);
   bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall);
   bool SemaBuiltinPPCMMACall(CallExpr *TheCall, unsigned BuiltinID,
                              const char *TypeDesc);
 
   bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc);
 
+  ExprResult SemaBuiltinElementwiseMath(CallExpr *TheCall,
+                                        ExprResult CallResult);
+
   // Matrix builtin handling.
   ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall,
                                         ExprResult CallResult);
   ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
                                               ExprResult CallResult);
   ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
                                                ExprResult CallResult);
 

clang/lib/CodeGen/CGBuiltin.cpp

Value *Sub =
         Builder.CreateSub(llvm::ConstantInt::get(IntTy, ExpMask), AbsV);
     // V = sign bit (Sub) <=> V = (Sub < 0)
     V = Builder.CreateLShr(Sub, llvm::ConstantInt::get(IntTy, bitsize - 1));
     if (bitsize > 32)
       V = Builder.CreateTrunc(V, ConvertType(E->getType()));
     return RValue::get(V);
   }
 
+  case Builtin::BI__builtin_elementwise_max: {
+    Value *Op0 = EmitScalarExpr(E->getArg(0));
+    Value *Op1 = EmitScalarExpr(E->getArg(1));
+    Value *Result;
+    if (Op0->getType()->isIntOrIntVectorTy()) {
+      QualType Ty = E->getArg(0)->getType();
+      if (auto *VecTy = Ty->getAs<VectorType>())
+        Ty = VecTy->getElementType();
+      Result = Builder.CreateBinaryIntrinsic(Ty->isSignedIntegerType()
+                                                 ? llvm::Intrinsic::smax
+                                                 : llvm::Intrinsic::umax,
+                                             Op0, Op1, nullptr, "elt.max");
+    } else
+      Result = Builder.CreateMaxNum(Op0, Op1, "elt.max");
+    return RValue::get(Result);
+  }
+  case Builtin::BI__builtin_elementwise_min: {
+    Value *Op0 = EmitScalarExpr(E->getArg(0));
+    Value *Op1 = EmitScalarExpr(E->getArg(1));
+    Value *Result;
+    if (Op0->getType()->isIntOrIntVectorTy()) {
+      QualType Ty = E->getArg(0)->getType();
+      if (auto *VecTy = Ty->getAs<VectorType>())
+        Ty = VecTy->getElementType();
+      Result = Builder.CreateBinaryIntrinsic(Ty->isSignedIntegerType()
+                                                 ? llvm::Intrinsic::smin
+                                                 : llvm::Intrinsic::umin,
+                                             Op0, Op1, nullptr, "elt.min");
+    } else
+      Result = Builder.CreateMinNum(Op0, Op1, "elt.min");
+    return RValue::get(Result);
+  }
+
   case Builtin::BI__builtin_matrix_transpose: {
     const auto *MatrixTy = E->getArg(0)->getType()->getAs<ConstantMatrixType>();
     Value *MatValue = EmitScalarExpr(E->getArg(0));
     MatrixBuilder<CGBuilderTy> MB(Builder);
     Value *Result = MB.CreateMatrixTranspose(MatValue, MatrixTy->getNumRows(),
                                              MatrixTy->getNumColumns());
     return RValue::get(Result);
   }

clang/lib/Sema/SemaChecking.cpp

if (!TheCall->getArg(0)->isValueDependent() &&
       Diag(TheCall->getBeginLoc(), diag::warn_frame_address)
           << ((BuiltinID == Builtin::BI__builtin_return_address)
                   ? "__builtin_return_address"
                   : "__builtin_frame_address")
           << TheCall->getSourceRange();
     break;
   }
 
+  case Builtin::BI__builtin_elementwise_min:
+  case Builtin::BI__builtin_elementwise_max:
+    return SemaBuiltinElementwiseMath(TheCall, TheCallResult);
+
   case Builtin::BI__builtin_matrix_transpose:
     return SemaBuiltinMatrixTranspose(TheCall, TheCallResult);
-
   case Builtin::BI__builtin_matrix_column_major_load:
     return SemaBuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
 
   case Builtin::BI__builtin_matrix_column_major_store:
     return SemaBuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
 
   case Builtin::BI__builtin_get_device_side_mangled_name: {
     auto Check = [](CallExpr *TheCall) {

 void Sema::CheckAddressOfPackedMember(Expr *rhs) {
   using namespace std::placeholders;
 
   RefersToMemberWithReducedAlignment(
       rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*this), _1,
                      _2, _3, _4));
 }
 
+// Check if \p Ty is a valid type for the elementwise math builtins. If it is
+// not a valid type, emit an error message and return true. Otherwise return
+// false.
+static bool checkMathBuiltinElementType(SourceLocation Loc, QualType Ty,
+                                        Sema &S) {
+  if (!Ty->getAs<VectorType>() && !ConstantMatrixType::isValidElementType(Ty)) {
+    S.Diag(Loc, diag::err_elementwise_math_invalid_arg_type) << Ty;
+    return true;
+  }
+  return false;
+}
+
+ExprResult Sema::SemaBuiltinElementwiseMath(CallExpr *TheCall,
+                                            ExprResult CallResult) {
+  if (checkArgCount(*this, TheCall, 2))
+    return ExprError();
+
+  Expr *A = TheCall->getArg(0);
+  Expr *B = TheCall->getArg(1);
+  QualType TyA = A->getType();
+  QualType TyB = B->getType();
+
+  if (TyA != TyB)
+    return Diag(A->getBeginLoc(), diag::err_elementwise_math_arg_types_mismatch)
+           << TyA << TyB;
+
+  if (checkMathBuiltinElementType(A->getBeginLoc(), TyA, *this))
+    return ExprError();
+
+  TheCall->setType(TyA);
+  return CallResult;
+}
+
 ExprResult Sema::SemaBuiltinMatrixTranspose(CallExpr *TheCall,
                                             ExprResult CallResult) {
   if (checkArgCount(*this, TheCall, 1))
     return ExprError();
 
   ExprResult MatrixArg = DefaultLvalueConversion(TheCall->getArg(0));
   if (MatrixArg.isInvalid())
     return MatrixArg;
   Expr *Matrix = MatrixArg.get();
 
   auto *MType = Matrix->getType()->getAs<ConstantMatrixType>();
   if (!MType) {
     Diag(Matrix->getBeginLoc(), diag::err_builtin_matrix_arg);
     return ExprError();

clang/test/CodeGen/builtins-elementwise-math.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+
+typedef float float4 __attribute__((ext_vector_type(4)));
+typedef short int si8 __attribute__((ext_vector_type(8)));
+typedef unsigned int u4 __attribute__((ext_vector_type(4)));
+
+void test_builtin_elementwise_max(float f1, float f2, double d1, double d2,
+                                  float4 vf1, float4 vf2, long long int i1,
+                                  long long int i2, si8 vi1, si8 vi2,
+                                  unsigned u1, unsigned u2, u4 vu1, u4 vu2) {
+  // CHECK-LABEL: define void @test_builtin_elementwise_max(
+
+  // CHECK:      [[F1:%.+]] = load float, float* %f1.addr, align 4
+  // CHECK-NEXT: [[F2:%.+]] = load float, float* %f2.addr, align 4
+  // CHECK-NEXT:  call float @llvm.maxnum.f32(float %0, float %1)
+  f1 = __builtin_elementwise_max(f1, f2);
+
+  // CHECK:      [[D1:%.+]] = load double, double* %d1.addr, align 8
+  // CHECK-NEXT: [[D2:%.+]] = load double, double* %d2.addr, align 8
+  // CHECK-NEXT: call double @llvm.maxnum.f64(double [[D1]], double [[D2]])
+  d1 = __builtin_elementwise_max(d1, d2);
+
+  // CHECK:      [[VF1:%.+]] = load <4 x float>, <4 x float>* %vf1.addr, align 16
+  // CHECK-NEXT: [[VF2:%.+]] = load <4 x float>, <4 x float>* %vf2.addr, align 16
+  // CHECK-NEXT: call <4 x float> @llvm.maxnum.v4f32(<4 x float> [[VF1]], <4 x float> [[VF2]])
+  vf1 = __builtin_elementwise_max(vf1, vf2);
+
+  // CHECK:      [[I1:%.+]] = load i64, i64* %i1.addr, align 8
+  // CHECK-NEXT: [[I2:%.+]] = load i64, i64* %i2.addr, align 8
+  // CHECK-NEXT: call i64 @llvm.smax.i64(i64 [[I1]], i64 [[I2]])
+  i1 = __builtin_elementwise_max(i1, i2);
+
+  // CHECK:      [[VI1:%.+]] = load <8 x i16>, <8 x i16>* %vi1.addr, align 16
+  // CHECK-NEXT: [[VI2:%.+]] = load <8 x i16>, <8 x i16>* %vi2.addr, align 16
+  // CHECK-NEXT: call <8 x i16> @llvm.smax.v8i16(<8 x i16> [[VI1]], <8 x i16> [[VI2]])
+  vi1 = __builtin_elementwise_max(vi1, vi2);
+
+  // CHECK:      [[U1:%.+]] = load i32, i32* %u1.addr, align 4
+  // CHECK-NEXT: [[U2:%.+]] = load i32, i32* %u2.addr, align 4
+  // CHECK-NEXT: call i32 @llvm.umax.i32(i32 [[U1]], i32 [[U2]])
+  u1 = __builtin_elementwise_max(u1, u2);
+
+  // CHECK:      [[VU1:%.+]] = load <4 x i32>, <4 x i32>* %vu1.addr, align 16
+  // CHECK-NEXT: [[VU2:%.+]] = load <4 x i32>, <4 x i32>* %vu2.addr, align 16
+  // CHECK-NEXT: call <4 x i32> @llvm.umax.v4i32(<4 x i32> [[VU1]], <4 x i32> [[VU2]])
+  vu1 = __builtin_elementwise_max(vu1, vu2);
+}
+
+void test_builtin_elementwise_min(float f1, float f2, double d1, double d2,
+                                  float4 vf1, float4 vf2, long long int i1,
+                                  long long int i2, si8 vi1, si8 vi2,
+                                  unsigned u1, unsigned u2, u4 vu1, u4 vu2) {
+  // CHECK-LABEL: define void @test_builtin_elementwise_min(
+  // CHECK:      [[F1:%.+]] = load float, float* %f1.addr, align 4
+  // CHECK-NEXT: [[F2:%.+]] = load float, float* %f2.addr, align 4
+  // CHECK-NEXT:  call float @llvm.minnum.f32(float %0, float %1)
+  f1 = __builtin_elementwise_min(f1, f2);
+
+  // CHECK:      [[D1:%.+]] = load double, double* %d1.addr, align 8
+  // CHECK-NEXT: [[D2:%.+]] = load double, double* %d2.addr, align 8
+  // CHECK-NEXT: call double @llvm.minnum.f64(double [[D1]], double [[D2]])
+  d1 = __builtin_elementwise_min(d1, d2);
+
+  // CHECK:      [[VF1:%.+]] = load <4 x float>, <4 x float>* %vf1.addr, align 16
+  // CHECK-NEXT: [[VF2:%.+]] = load <4 x float>, <4 x float>* %vf2.addr, align 16
+  // CHECK-NEXT: call <4 x float> @llvm.minnum.v4f32(<4 x float> [[VF1]], <4 x float> [[VF2]])
+  vf1 = __builtin_elementwise_min(vf1, vf2);
+
+  // CHECK:      [[I1:%.+]] = load i64, i64* %i1.addr, align 8
+  // CHECK-NEXT: [[I2:%.+]] = load i64, i64* %i2.addr, align 8
+  // CHECK-NEXT: call i64 @llvm.smin.i64(i64 [[I1]], i64 [[I2]])
+  i1 = __builtin_elementwise_min(i1, i2);
+
+  // CHECK:      [[VI1:%.+]] = load <8 x i16>, <8 x i16>* %vi1.addr, align 16
+  // CHECK-NEXT: [[VI2:%.+]] = load <8 x i16>, <8 x i16>* %vi2.addr, align 16
+  // CHECK-NEXT: call <8 x i16> @llvm.smin.v8i16(<8 x i16> [[VI1]], <8 x i16> [[VI2]])
+  vi1 = __builtin_elementwise_min(vi1, vi2);
+
+  // CHECK:      [[U1:%.+]] = load i32, i32* %u1.addr, align 4
+  // CHECK-NEXT: [[U2:%.+]] = load i32, i32* %u2.addr, align 4
+  // CHECK-NEXT: call i32 @llvm.umin.i32(i32 [[U1]], i32 [[U2]])
+  u1 = __builtin_elementwise_min(u1, u2);
+
+  // CHECK:      [[VU1:%.+]] = load <4 x i32>, <4 x i32>* %vu1.addr, align 16
+  // CHECK-NEXT: [[VU2:%.+]] = load <4 x i32>, <4 x i32>* %vu2.addr, align 16
+  // CHECK-NEXT: call <4 x i32> @llvm.umin.v4i32(<4 x i32> [[VU1]], <4 x i32> [[VU2]])
+  vu1 = __builtin_elementwise_min(vu1, vu2);
+}

clang/test/Sema/builtins-elementwise-math.c

+// RUN: %clang_cc1 %s -pedantic -verify -triple=x86_64-apple-darwin9
+
+typedef float float4 __attribute__((ext_vector_type(4)));
+typedef int int3 __attribute__((ext_vector_type(3)));
+
+struct Foo {
+  char *p;
+};
+
+void test_builtin_elementwise_max(int i, double d, float4 v, int3 iv) {
+  i = __builtin_elementwise_max(i, d);
+  // expected-error@-1 {{argument types do not match, 'int' != 'double'}}
+
+  struct Foo s = __builtin_elementwise_max(i, i);
+  // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
+
+  i = __builtin_elementwise_max(i);
+  // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
+
+  i = __builtin_elementwise_max();
+  // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
+
+  i = __builtin_elementwise_max(v, iv);
+  // expected-error@-1 {{argument types do not match, 'float4' (vector of 4 'float' values) != 'int3' (vector of 3 'int' values)}}
+}
+
+void test_builtin_elementwise_min(int i, double d, float4 v, int3 iv) {
+  i = __builtin_elementwise_min(i, d);
+  // expected-error@-1 {{argument types do not match, 'int' != 'double'}}
+
+  struct Foo s = __builtin_elementwise_min(i, i);
+  // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
+
+  i = __builtin_elementwise_min(i);
+  // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
+
+  i = __builtin_elementwise_min();
+  // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
+
+  i = __builtin_elementwise_min(v, iv);
+  // expected-error@-1 {{argument types do not match, 'float4' (vector of 4 'float' values) != 'int3' (vector of 3 'int' values)}}
+}