[x86] Teach the builtin argument range check to allow invalid ranges in dead code.

[chandlerc]

Summary

This is important for C++ templates that essentially compute the valid
input in a way that is constant and will cause all the invalid cases to
be dead code that is deleted. Code in the wild actually does this and
GCC also accepts these kinds of patterns so it is important to support
it.

To make this work, we provide a non-error path to diagnose these issues,
and use a default-error warning instead. This keeps the relatively
strict handling but prevents nastiness like SFINAE on these errors. It
also allows us to safely use the system to diagnose this only when it
occurs at runtime (in emitted code).

Entertainingly, this required fixing the syntax in various other ways
for the x86 test because we never bothered to diagnose that the returns
were invalid.

Since debugging these compile failures was super confusing, I've also
improved the diagnostic to actually say what the value was. Most of the
checks I've made ignore this to simplify maintenance, but I've checked
it in a few places to make sure the diagnsotic is working.

Depends on D48462. Without that, we might actually crash some part of
the compiler after bypassing the error here.

Thanks to Richard, Ben Kramer, and especially Craig Topper for all the
help here.

[craig.topper]

LGTM

include/clang/Basic/DiagnosticSemaKinds.td

 
 def err_vector_incorrect_num_initializers : Error<
   "%select{too many|too few}0 elements in vector initialization (expected %1 elements, have %2)">;
 def err_altivec_empty_initializer : Error<"expected initializer">;
 
 def err_invalid_neon_type_code : Error<
   "incompatible constant for this __builtin_neon function">; 
 def err_argument_invalid_range : Error<
-  "argument should be a value from %0 to %1">;
+  "argument value %0 is outside the valid range [%1, %2]">;
+def warn_argument_invalid_range : Warning<
+  "argument value %0 is outside the valid range [%1, %2]">, DefaultError,
+  InGroup<DiagGroup<"argument-outside-range">>;
 def err_argument_not_multiple : Error<
   "argument should be a multiple of %0">;
 def warn_neon_vector_initializer_non_portable : Warning<
   "vector initializers are not compatible with NEON intrinsics in big endian "
   "mode">, InGroup<DiagGroup<"nonportable-vector-initialization">>;
 def note_neon_vector_initializer_non_portable : Note<
   "consider using vld1_%0%1() to initialize a vector from memory, or "
   "vcreate_%0%1() to initialize from an integer constant">;

include/clang/Sema/Sema.h

private:
   ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
   ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);
   ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
                                      AtomicExpr::AtomicOp Op);
   ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,
                                                     bool IsDelete);
   bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
                               llvm::APSInt &Result);
-  bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
-                                   int Low, int High);
+  bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,
+                                   int High, bool RangeIsError = true);
   bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
                                       unsigned Multiple);
   bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
                                 int ArgNum, unsigned ExpectedFieldNum,
                                 bool AllowName);
 public:
   enum FormatStringType {
     FST_Scanf,

lib/Sema/SemaChecking.cpp

bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
   case X86::BI__builtin_ia32_scatterpfqps:
     i = 4; l = 2; u = 3;
     break;
   case X86::BI__builtin_ia32_rndscalesd_round_mask:
   case X86::BI__builtin_ia32_rndscaless_round_mask:
     i = 4; l = 0; u = 255;
     break;
   }
-  return SemaBuiltinConstantArgRange(TheCall, i, l, u);
+
+  // Note that we don't force a hard error on the range check here, allowing
+  // template-generated or macro-generated dead code to potentially have out-of-
+  // range values. These need to code generate, but don't need to necessarily
+  // make any sense. We use a warning that defaults to an error.
+  return SemaBuiltinConstantArgRange(TheCall, i, l, u, /*RangeIsError*/ false);
 }
 
 /// Given a FunctionDecl's FormatAttr, attempts to populate the FomatStringInfo
 /// parameter with the FormatAttr's correct format_idx and firstDataArg.
 /// Returns true when the format fits the function and the FormatStringInfo has
 /// been populated.
 bool Sema::getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
                                FormatStringInfo *FSI) {
return Diag(TheCall->getLocStart(), diag::err_constant_integer_arg_type)
                 << FDecl->getDeclName() <<  Arg->getSourceRange();
   
   return false;
 }
 
 /// SemaBuiltinConstantArgRange - Handle a check if argument ArgNum of CallExpr
 /// TheCall is a constant expression in the range [Low, High].
 bool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
-                                       int Low, int High) {
+                                       int Low, int High, bool RangeIsError) {
   llvm::APSInt Result;
 
   // We can't check the value of a dependent argument.
   Expr *Arg = TheCall->getArg(ArgNum);
   if (Arg->isTypeDependent() || Arg->isValueDependent())
     return false;
 
   // Check constant-ness first.
   if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
     return true;
 
-  if (Result.getSExtValue() < Low || Result.getSExtValue() > High)
+  if (Result.getSExtValue() < Low || Result.getSExtValue() > High) {
+    if (RangeIsError)
       return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
-      << Low << High << Arg->getSourceRange();
+             << Result.toString(10) << Low << High << Arg->getSourceRange();
+    else
+      // Defer the warning until we know if the code will be emitted so that
+      // dead code can ignore this.
+      DiagRuntimeBehavior(TheCall->getLocStart(), TheCall,
+                            PDiag(diag::warn_argument_invalid_range)
+                                << Result.toString(10) << Low << High
+                                << Arg->getSourceRange());
+  }
 
   return false;
 }
 
 /// SemaBuiltinConstantArgMultiple - Handle a check if argument ArgNum of CallExpr
 /// TheCall is a constant expression is a multiple of Num..
 bool Sema::SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
                                           unsigned Num) {

test/CodeGen/builtins-mips-args.c

 // REQUIRES: mips-registered-target
 // RUN: %clang_cc1 -triple mips-unknown-linux-gnu -fsyntax-only -verify %s
 
 void foo() {
   // MIPS DSP Rev 1
 
   int a = 3;
   __builtin_mips_wrdsp(2052, a);  // expected-error{{argument to '__builtin_mips_wrdsp' must be a constant integer}}
   __builtin_mips_rddsp(a);        // expected-error{{argument to '__builtin_mips_rddsp' must be a constant integer}}
-  __builtin_mips_wrdsp(2052, -1); // expected-error{{argument should be a value from 0 to 63}}
-  __builtin_mips_rddsp(-1);       // expected-error{{argument should be a value from 0 to 63}}
-  __builtin_mips_wrdsp(2052, 64); // expected-error{{argument should be a value from 0 to 63}}
-  __builtin_mips_rddsp(64);       // expected-error{{argument should be a value from 0 to 63}}
+  __builtin_mips_wrdsp(2052, -1); // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_rddsp(-1);       // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_wrdsp(2052, 64); // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_rddsp(64);       // expected-error-re{{argument value {{.*}} is outside the valid range}}
 
   // MIPS DSP Rev 2
 
   __builtin_mips_append(1, 2, a); // expected-error{{argument to '__builtin_mips_append' must be a constant integer}}
   __builtin_mips_balign(1, 2, a); // expected-error{{argument to '__builtin_mips_balign' must be a constant integer}}
   __builtin_mips_precr_sra_ph_w(1, 2, a);   // expected-error{{argument to '__builtin_mips_precr_sra_ph_w' must be a constant integer}}
   __builtin_mips_precr_sra_r_ph_w(1, 2, a); // expected-error{{argument to '__builtin_mips_precr_sra_r_ph_w' must be a constant integer}}
   __builtin_mips_prepend(1, 2, a);          // expected-error{{argument to '__builtin_mips_prepend' must be a constant integer}}
 
-  __builtin_mips_append(1, 2, -1);  // expected-error{{argument should be a value from 0 to 31}}
-  __builtin_mips_append(1, 2, 32);  // expected-error{{argument should be a value from 0 to 31}}
+  __builtin_mips_append(1, 2, -1);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_append(1, 2, 32);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
 
-  __builtin_mips_balign(1, 2, -1);  // expected-error{{argument should be a value from 0 to 3}}
-  __builtin_mips_balign(1, 2, 4);   // expected-error{{argument should be a value from 0 to 3}}
+  __builtin_mips_balign(1, 2, -1);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_balign(1, 2, 4);   // expected-error-re{{argument value {{.*}} is outside the valid range}}
 
-  __builtin_mips_precr_sra_ph_w(1, 2, -1);  // expected-error{{argument should be a value from 0 to 31}}
-  __builtin_mips_precr_sra_ph_w(1, 2, 32);  // expected-error{{argument should be a value from 0 to 31}}
+  __builtin_mips_precr_sra_ph_w(1, 2, -1);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_precr_sra_ph_w(1, 2, 32);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
 
-  __builtin_mips_precr_sra_r_ph_w(1, 2, -1);  // expected-error{{argument should be a value from 0 to 31}}
-  __builtin_mips_precr_sra_r_ph_w(1, 2, 32);  // expected-error{{argument should be a value from 0 to 31}}
+  __builtin_mips_precr_sra_r_ph_w(1, 2, -1);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_precr_sra_r_ph_w(1, 2, 32);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
 
-  __builtin_mips_prepend(1, 2, -1); // expected-error{{argument should be a value from 0 to 31}}
-  __builtin_mips_prepend(1, 2, -1); // expected-error{{argument should be a value from 0 to 31}}
+  __builtin_mips_prepend(1, 2, -1); // expected-error-re{{argument value {{.*}} is outside the valid range}}
+  __builtin_mips_prepend(1, 2, -1); // expected-error-re{{argument value {{.*}} is outside the valid range}}
 }

test/CodeGen/builtins-systemz-vector-error.c

 volatile vec_ulong vul;
 volatile vec_double vd;
 
 volatile unsigned int len;
 const void * volatile cptr;
 int cc;
 
 void test_core(void) {
-  __builtin_s390_lcbb(cptr, -1);       // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_lcbb(cptr, 16);       // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_lcbb(cptr, -1);       // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_lcbb(cptr, 16);       // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_lcbb(cptr, len);      // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vlbb(cptr, -1);       // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vlbb(cptr, 16);       // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vlbb(cptr, -1);       // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vlbb(cptr, 16);       // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vlbb(cptr, len);      // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vpdi(vul, vul, -1);   // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vpdi(vul, vul, 16);   // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vpdi(vul, vul, -1);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vpdi(vul, vul, 16);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vpdi(vul, vul, len);  // expected-error {{must be a constant integer}}
 }
 
 void test_integer(void) {
-  __builtin_s390_verimb(vuc, vuc, vuc, -1);    // expected-error {{argument should be a value from 0 to 255}}
-  __builtin_s390_verimb(vuc, vuc, vuc, 256);   // expected-error {{argument should be a value from 0 to 255}}
+  __builtin_s390_verimb(vuc, vuc, vuc, -1);    // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_verimb(vuc, vuc, vuc, 256);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_verimb(vuc, vuc, vuc, len);   // expected-error {{must be a constant integer}}
 
-  __builtin_s390_verimh(vus, vus, vus, -1);    // expected-error {{argument should be a value from 0 to 255}}
-  __builtin_s390_verimh(vus, vus, vus, 256);   // expected-error {{argument should be a value from 0 to 255}}
+  __builtin_s390_verimh(vus, vus, vus, -1);    // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_verimh(vus, vus, vus, 256);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_verimh(vus, vus, vus, len);   // expected-error {{must be a constant integer}}
 
-  __builtin_s390_verimf(vui, vui, vui, -1);    // expected-error {{argument should be a value from 0 to 255}}
-  __builtin_s390_verimf(vui, vui, vui, 256);   // expected-error {{argument should be a value from 0 to 255}}
+  __builtin_s390_verimf(vui, vui, vui, -1);    // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_verimf(vui, vui, vui, 256);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_verimf(vui, vui, vui, len);   // expected-error {{must be a constant integer}}
 
-  __builtin_s390_verimg(vul, vul, vul, -1);    // expected-error {{argument should be a value from 0 to 255}}
-  __builtin_s390_verimg(vul, vul, vul, 256);   // expected-error {{argument should be a value from 0 to 255}}
+  __builtin_s390_verimg(vul, vul, vul, -1);    // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_verimg(vul, vul, vul, 256);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_verimg(vul, vul, vul, len);   // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vsldb(vuc, vuc, -1);          // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vsldb(vuc, vuc, 16);          // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vsldb(vuc, vuc, -1);          // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vsldb(vuc, vuc, 16);          // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vsldb(vuc, vuc, len);         // expected-error {{must be a constant integer}}
 }
 
 void test_string(void) {
-  __builtin_s390_vfaeb(vuc, vuc, -1);               // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaeb(vuc, vuc, 16);               // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaeb(vuc, vuc, -1);               // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaeb(vuc, vuc, 16);               // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaeb(vuc, vuc, len);              // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaeh(vus, vus, -1);               // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaeh(vus, vus, 16);               // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaeh(vus, vus, -1);               // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaeh(vus, vus, 16);               // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaeh(vus, vus, len);              // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaef(vui, vui, -1);               // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaef(vui, vui, 16);               // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaef(vui, vui, -1);               // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaef(vui, vui, 16);               // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaef(vui, vui, len);              // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaezb(vuc, vuc, -1);              // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaezb(vuc, vuc, 16);              // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaezb(vuc, vuc, -1);              // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaezb(vuc, vuc, 16);              // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaezb(vuc, vuc, len);             // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaezh(vus, vus, -1);              // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaezh(vus, vus, 16);              // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaezh(vus, vus, -1);              // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaezh(vus, vus, 16);              // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaezh(vus, vus, len);             // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaezf(vui, vui, -1);              // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaezf(vui, vui, 16);              // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaezf(vui, vui, -1);              // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaezf(vui, vui, 16);              // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaezf(vui, vui, len);             // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrcb(vuc, vuc, vuc, -1);         // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrcb(vuc, vuc, vuc, 16);         // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrcb(vuc, vuc, vuc, -1);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrcb(vuc, vuc, vuc, 16);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrcb(vuc, vuc, vuc, len);        // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrch(vus, vus, vus, -1);         // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrch(vus, vus, vus, 16);         // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrch(vus, vus, vus, -1);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrch(vus, vus, vus, 16);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrch(vus, vus, vus, len);        // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrcf(vui, vui, vui, -1);         // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrcf(vui, vui, vui, 16);         // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrcf(vui, vui, vui, -1);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrcf(vui, vui, vui, 16);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrcf(vui, vui, vui, len);        // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrczb(vuc, vuc, vuc, -1);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrczb(vuc, vuc, vuc, 16);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrczb(vuc, vuc, vuc, -1);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrczb(vuc, vuc, vuc, 16);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrczb(vuc, vuc, vuc, len);       // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrczh(vus, vus, vus, -1);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrczh(vus, vus, vus, 16);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrczh(vus, vus, vus, -1);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrczh(vus, vus, vus, 16);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrczh(vus, vus, vus, len);       // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrczf(vui, vui, vui, -1);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrczf(vui, vui, vui, 16);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrczf(vui, vui, vui, -1);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrczf(vui, vui, vui, 16);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrczf(vui, vui, vui, len);       // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaebs(vuc, vuc, -1, &cc);         // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaebs(vuc, vuc, 16, &cc);         // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaebs(vuc, vuc, -1, &cc);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaebs(vuc, vuc, 16, &cc);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaebs(vuc, vuc, len, &cc);        // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaehs(vus, vus, -1, &cc);         // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaehs(vus, vus, 16, &cc);         // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaehs(vus, vus, -1, &cc);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaehs(vus, vus, 16, &cc);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaehs(vus, vus, len, &cc);        // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaefs(vui, vui, -1, &cc);         // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaefs(vui, vui, 16, &cc);         // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaefs(vui, vui, -1, &cc);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaefs(vui, vui, 16, &cc);         // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaefs(vui, vui, len, &cc);        // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaezbs(vuc, vuc, -1, &cc);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaezbs(vuc, vuc, 16, &cc);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaezbs(vuc, vuc, -1, &cc);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaezbs(vuc, vuc, 16, &cc);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaezbs(vuc, vuc, len, &cc);       // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaezhs(vus, vus, -1, &cc);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaezhs(vus, vus, 16, &cc);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaezhs(vus, vus, -1, &cc);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaezhs(vus, vus, 16, &cc);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaezhs(vus, vus, len, &cc);       // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfaezfs(vui, vui, -1, &cc);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfaezfs(vui, vui, 16, &cc);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfaezfs(vui, vui, -1, &cc);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfaezfs(vui, vui, 16, &cc);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfaezfs(vui, vui, len, &cc);       // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrcbs(vuc, vuc, vuc, -1, &cc);   // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrcbs(vuc, vuc, vuc, 16, &cc);   // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrcbs(vuc, vuc, vuc, -1, &cc);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrcbs(vuc, vuc, vuc, 16, &cc);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrcbs(vuc, vuc, vuc, len, &cc);  // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrchs(vus, vus, vus, -1, &cc);   // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrchs(vus, vus, vus, 16, &cc);   // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrchs(vus, vus, vus, -1, &cc);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrchs(vus, vus, vus, 16, &cc);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrchs(vus, vus, vus, len, &cc);  // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrcfs(vui, vui, vui, -1, &cc);   // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrcfs(vui, vui, vui, 16, &cc);   // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrcfs(vui, vui, vui, -1, &cc);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrcfs(vui, vui, vui, 16, &cc);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrcfs(vui, vui, vui, len, &cc);  // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrczbs(vuc, vuc, vuc, -1, &cc);  // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrczbs(vuc, vuc, vuc, 16, &cc);  // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrczbs(vuc, vuc, vuc, -1, &cc);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrczbs(vuc, vuc, vuc, 16, &cc);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrczbs(vuc, vuc, vuc, len, &cc); // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrczhs(vus, vus, vus, -1, &cc);  // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrczhs(vus, vus, vus, 16, &cc);  // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrczhs(vus, vus, vus, -1, &cc);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrczhs(vus, vus, vus, 16, &cc);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrczhs(vus, vus, vus, len, &cc); // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vstrczfs(vui, vui, vui, -1, &cc);  // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vstrczfs(vui, vui, vui, 16, &cc);  // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vstrczfs(vui, vui, vui, -1, &cc);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vstrczfs(vui, vui, vui, 16, &cc);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vstrczfs(vui, vui, vui, len, &cc); // expected-error {{must be a constant integer}}
 }
 
 void test_float(void) {
-  __builtin_s390_vftcidb(vd, -1, &cc);              // expected-error {{argument should be a value from 0 to 4095}}
-  __builtin_s390_vftcidb(vd, 4096, &cc);            // expected-error {{argument should be a value from 0 to 4095}}
+  __builtin_s390_vftcidb(vd, -1, &cc);              // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vftcidb(vd, 4096, &cc);            // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vftcidb(vd, len, &cc);             // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfidb(vd, -1, 0);                  // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfidb(vd, 16, 0);                  // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfidb(vd, -1, 0);                  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfidb(vd, 16, 0);                  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfidb(vd, len, 0);                 // expected-error {{must be a constant integer}}
-  __builtin_s390_vfidb(vd, 0, -1);                  // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfidb(vd, 0, 16);                  // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfidb(vd, 0, -1);                  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfidb(vd, 0, 16);                  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfidb(vd, 0, len);                 // expected-error {{must be a constant integer}}
 }

test/CodeGen/builtins-systemz-vector2-error.c

 volatile vec_ulong vul;
 volatile vec_double vd;
 volatile vec_float vf;
 
 volatile unsigned int len;
 int cc;
 
 void test_integer(void) {
-  __builtin_s390_vmslg(vul, vul, vuc, -1);   // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vmslg(vul, vul, vuc, 16);   // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vmslg(vul, vul, vuc, -1);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vmslg(vul, vul, vuc, 16);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vmslg(vul, vul, vuc, len);  // expected-error {{must be a constant integer}}
 }
 
 void test_float(void) {
-  __builtin_s390_vfmaxdb(vd, vd, -1);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfmaxdb(vd, vd, 16);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfmaxdb(vd, vd, -1);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfmaxdb(vd, vd, 16);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfmaxdb(vd, vd, len);       // expected-error {{must be a constant integer}}
-  __builtin_s390_vfmindb(vd, vd, -1);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfmindb(vd, vd, 16);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfmindb(vd, vd, -1);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfmindb(vd, vd, 16);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfmindb(vd, vd, len);       // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vftcisb(vf, -1, &cc);       // expected-error {{argument should be a value from 0 to 4095}}
-  __builtin_s390_vftcisb(vf, 4096, &cc);     // expected-error {{argument should be a value from 0 to 4095}}
+  __builtin_s390_vftcisb(vf, -1, &cc);       // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vftcisb(vf, 4096, &cc);     // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vftcisb(vf, len, &cc);      // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfisb(vf, -1, 0);           // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfisb(vf, 16, 0);           // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfisb(vf, -1, 0);           // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfisb(vf, 16, 0);           // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfisb(vf, len, 0);          // expected-error {{must be a constant integer}}
-  __builtin_s390_vfisb(vf, 0, -1);           // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfisb(vf, 0, 16);           // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfisb(vf, 0, -1);           // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfisb(vf, 0, 16);           // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfisb(vf, 0, len);          // expected-error {{must be a constant integer}}
 
-  __builtin_s390_vfmaxsb(vf, vf, -1);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfmaxsb(vf, vf, 16);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfmaxsb(vf, vf, -1);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfmaxsb(vf, vf, 16);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfmaxsb(vf, vf, len);       // expected-error {{must be a constant integer}}
-  __builtin_s390_vfminsb(vf, vf, -1);        // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_s390_vfminsb(vf, vf, 16);        // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_s390_vfminsb(vf, vf, -1);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_s390_vfminsb(vf, vf, 16);        // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_s390_vfminsb(vf, vf, len);       // expected-error {{must be a constant integer}}
 }

test/CodeGen/builtins-systemz-zvector-error.c

void test_float(void) {
   vul = vec_ctul(vd, idx); // expected-error {{no matching function}}
                            // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
   vul = vec_ctul(vd, -1);  // expected-error {{no matching function}}
                            // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
   vul = vec_ctul(vd, 32);  // expected-error {{no matching function}}
                            // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
 
   vbl = vec_fp_test_data_class(vd, idx, &cc);  // expected-error {{must be a constant integer}}
-  vbl = vec_fp_test_data_class(vd, -1, &cc);   // expected-error {{should be a value from 0 to 4095}}
-  vbl = vec_fp_test_data_class(vd, 4096, &cc); // expected-error {{should be a value from 0 to 4095}}
+  vbl = vec_fp_test_data_class(vd, -1, &cc);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vbl = vec_fp_test_data_class(vd, 4096, &cc); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }

test/CodeGen/builtins-systemz-zvector2-error.c

void test_integer(void) {
   vf = vec_sld(vf, vf, idx);    // expected-error {{no matching function}}
                                 // expected-note@vecintrin.h:* 13 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
   vd = vec_sld(vd, vd, idx);    // expected-error {{no matching function}}
                                 // expected-note@vecintrin.h:* 13 {{candidate function not viable}}
                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
 
   vuc = vec_msum_u128(vul, vul, vuc, idx);  // expected-error {{must be a constant integer}}
-  vuc = vec_msum_u128(vul, vul, vuc, -1);   // expected-error {{should be a value from 0 to 15}}
-  vuc = vec_msum_u128(vul, vul, vuc, 16);   // expected-error {{should be a value from 0 to 15}}
+  vuc = vec_msum_u128(vul, vul, vuc, -1);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vuc = vec_msum_u128(vul, vul, vuc, 16);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_float(void) {
   vbi = vec_fp_test_data_class(vf, idx, &cc);   // expected-error {{no matching function}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}
                                                 // expected-note@vecintrin.h:* 1 {{must be a constant integer from 0 to 4095}}
   vbi = vec_fp_test_data_class(vf, -1, &cc);    // expected-error {{no matching function}}
                                                 // expected-note@vecintrin.h:* 1 {{candidate function not viable}}

test/CodeGen/hexagon-check-builtins.c

 // REQUIRES: hexagon-registered-target
 // RUN: %clang_cc1 -fsyntax-only -triple hexagon-unknown-elf -verify %s
 
 int foo(int x) {
-  // expected-error@+2 {{argument should be a value from 0 to 31}}
-  // expected-error@+1 {{argument should be a value from 0 to 31}}
+  // expected-error-re@+2 {{argument value {{.*}} is outside the valid range}}
+  // expected-error-re@+1 {{argument value {{.*}} is outside the valid range}}
   return __builtin_HEXAGON_S4_extract(x, 33, -1) +
-  // expected-error@+1 {{argument should be a value from 0 to 31}}
+  // expected-error-re@+1 {{argument value {{.*}} is outside the valid range}}
          __builtin_HEXAGON_S4_extract(x, 3, 91) +
-  // expected-error@+2 {{argument should be a value from 0 to 31}}
-  // expected-error@+1 {{argument should be a value from 0 to 31}}
+  // expected-error-re@+2 {{argument value {{.*}} is outside the valid range}}
+  // expected-error-re@+1 {{argument value {{.*}} is outside the valid range}}
          __builtin_HEXAGON_S4_extract(x, -1, 35) +
          __builtin_HEXAGON_S4_extract(x, 0, 31) +
          __builtin_HEXAGON_S4_extract(x, 31, 0);
 }
 
 int bar(void *p, void *q, int x) {
   // expected-error@+1 {{argument should be a multiple of 4}}
   return __builtin_HEXAGON_L2_loadri_pci(p, -1, x, q) +
-  // expected-error@+2 {{argument should be a value from -32 to 28}}
+  // expected-error-re@+2 {{argument value {{.*}} is outside the valid range}}
   // expected-error@+1 {{argument should be a multiple of 4}}
          __builtin_HEXAGON_L2_loadri_pci(p, -99, x, q) +
-  // expected-error@+1 {{argument should be a value from -32 to 28}}
+  // expected-error-re@+1 {{argument value {{.*}} is outside the valid range}}
          __builtin_HEXAGON_L2_loadri_pci(p, -132, x, q) +
          __builtin_HEXAGON_L2_loadri_pci(p, 28, x, q) +
-  // expected-error@+2 {{argument should be a value from -32 to 28}}
+  // expected-error-re@+2 {{argument value {{.*}} is outside the valid range}}
   // expected-error@+1 {{argument should be a multiple of 4}}
          __builtin_HEXAGON_L2_loadri_pci(p, 29, x, q);
 }
 

test/Sema/aarch64-neon-fp16-ranges.c

 // RUN: %clang_cc1 -triple arm64-linux-gnu -fallow-half-arguments-and-returns -target-feature +neon -target-feature +fullfp16 -ffreestanding -fsyntax-only -verify %s
 // RUN: %clang_cc1 -triple aarch64-linux-gnu -fallow-half-arguments-and-returns -target-feature +fullfp16 -target-feature +neon -ffreestanding -fsyntax-only -verify %s    
 
 #include <arm_neon.h>
 #include <arm_fp16.h>
 
 void test_vcvt_f16_16(int16_t a){
   vcvth_n_f16_s16(a, 1);
   vcvth_n_f16_s16(a, 16);
-  vcvth_n_f16_s16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_f16_s16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_f16_s16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_f16_s16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vcvth_n_f16_u16(a, 1);
   vcvth_n_f16_u16(a, 16);
-  vcvth_n_f16_u16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_f16_u16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_f16_u16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_f16_u16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_vcvt_f16_32(int32_t a){
   vcvth_n_f16_u32(a, 1);
   vcvth_n_f16_u32(a, 16);
-  vcvth_n_f16_u32(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_f16_u32(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_f16_u32(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_f16_u32(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vcvth_n_f16_s32(a, 1);
   vcvth_n_f16_s32(a, 16);
-  vcvth_n_f16_s32(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_f16_s32(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_f16_s32(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_f16_s32(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_vcvt_f16_64(int64_t a){
   vcvth_n_f16_s64(a, 1);
   vcvth_n_f16_s64(a, 16);
-  vcvth_n_f16_s64(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_f16_s64(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_f16_s64(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_f16_s64(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 
 void test_vcvt_su_f(float16_t a){
   vcvth_n_s16_f16(a, 1);
   vcvth_n_s16_f16(a, 16);
-  vcvth_n_s16_f16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_s16_f16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_s16_f16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_s16_f16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vcvth_n_s32_f16(a, 1);
   vcvth_n_s32_f16(a, 16);
-  vcvth_n_s32_f16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_s32_f16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_s32_f16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_s32_f16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vcvth_n_s64_f16(a, 1);
   vcvth_n_s64_f16(a, 16);
-  vcvth_n_s64_f16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_s64_f16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_s64_f16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_s64_f16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vcvth_n_u16_f16(a, 1);
   vcvth_n_u16_f16(a, 16);
-  vcvth_n_u16_f16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_u16_f16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_u16_f16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_u16_f16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vcvth_n_u32_f16(a, 1);
   vcvth_n_u32_f16(a, 16);
-  vcvth_n_u32_f16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  vcvth_n_u32_f16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  vcvth_n_u32_f16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vcvth_n_u32_f16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }

test/Sema/aarch64-neon-ranges.c

 // RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +neon -ffreestanding -fsyntax-only -verify %s
 // RUN: %clang_cc1 -triple arm64-linux-gnu -target-feature +neon -ffreestanding -fsyntax-only -verify %s
 
 #include <arm_neon.h>
 
 void test_vext_8bit(int8x8_t small, int8x16_t big) {
   vext_s8(small, small, 7);
   vext_u8(small, small, 7);
   vext_p8(small, small, 7);
   vextq_s8(big, big, 15);
   vextq_u8(big, big, 15);
   vextq_p8(big, big, 15);
 
-  vext_s8(small, small, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vext_u8(small, small, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vext_p8(small, small, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vextq_s8(big, big, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vextq_u8(big, big, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vextq_p8(big, big, 16); // expected-error {{argument should be a value from 0 to 15}}
+  vext_s8(small, small, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vext_u8(small, small, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vext_p8(small, small, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vextq_s8(big, big, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vextq_u8(big, big, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vextq_p8(big, big, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_mul_lane_f64(float64x1_t small, float64x2_t big, float64x2_t rhs) {
   vmul_lane_f64(small, small, 0);
   vmul_laneq_f64(small, big, 1);
   vmulq_lane_f64(big, small, 0);
   vmulq_laneq_f64(big, big, 1);
   vfma_lane_f64(small, small, small, 0);
   vfma_laneq_f64(small, small, big, 1);
   vfmaq_lane_f64(big, big, small, 0);
   vfmaq_laneq_f64(big, big, big, 1);
 
-  vmul_lane_f64(small, small, 1); // expected-error {{argument should be a value from 0 to 0}}
-  vmul_laneq_f64(small, big, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vfma_lane_f64(small, small, small, 1); // expected-error {{argument should be a value from 0 to 0}}
-  vfma_laneq_f64(small, small, big, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vfmaq_laneq_f64(big, big, big, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vmul_lane_f64(small, small, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vmul_laneq_f64(small, big, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vfma_lane_f64(small, small, small, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vfma_laneq_f64(small, small, big, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vfmaq_laneq_f64(big, big, big, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_ld1st1(int8x8_t small, int8x16_t big, void *addr) {
   vld1_lane_s8(addr, small, 7);
   vld1_lane_s16(addr, small, 3);
   vld1_lane_s32(addr, small, 1);
   vld1_lane_s64(addr, small, 0);
 
   vld1q_lane_s8(addr, big, 15);
   vld1q_lane_s16(addr, big, 7);
   vld1q_lane_s32(addr, big, 3);
   vld1q_lane_s64(addr, big, 1);
 
-  vld1_lane_s8(addr, small, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld1_lane_s16(addr, small, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld1_lane_s32(addr, small, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vld1_lane_s64(addr, small, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vld1q_lane_s8(addr, big, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vld1q_lane_s16(addr, big, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld1q_lane_s32(addr, big, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld1q_lane_s64(addr, big, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vld1_lane_s8(addr, small, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld1_lane_s16(addr, small, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld1_lane_s32(addr, small, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld1_lane_s64(addr, small, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vld1q_lane_s8(addr, big, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld1q_lane_s16(addr, big, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld1q_lane_s32(addr, big, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld1q_lane_s64(addr, big, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vst1_lane_s8(addr, small, 7);
   vst1_lane_s16(addr, small, 3);
   vst1_lane_s32(addr, small, 1);
   vst1_lane_s64(addr, small, 0);
 
   vst1q_lane_s8(addr, big, 15);
   vst1q_lane_s16(addr, big, 7);
   vst1q_lane_s32(addr, big, 3);
   vst1q_lane_s64(addr, big, 1);
 
-  vst1_lane_s8(addr, small, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst1_lane_s16(addr, small, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst1_lane_s32(addr, small, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vst1_lane_s64(addr, small, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vst1q_lane_s8(addr, big, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vst1q_lane_s16(addr, big, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst1q_lane_s32(addr, big, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst1q_lane_s64(addr, big, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vst1_lane_s8(addr, small, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst1_lane_s16(addr, small, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst1_lane_s32(addr, small, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst1_lane_s64(addr, small, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vst1q_lane_s8(addr, big, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst1q_lane_s16(addr, big, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst1q_lane_s32(addr, big, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst1q_lane_s64(addr, big, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_ld2st2(int8x8x2_t small8, int8x16x2_t big8,
                  int16x4x2_t small16, int16x8x2_t big16,
                  int32x2x2_t small32, int32x4x2_t big32,
                  int64x1x2_t small64, int64x2x2_t big64,
                  void *addr) {
   vld2_lane_s8(addr, small8, 7);
   vld2_lane_s16(addr, small16, 3);
   vld2_lane_s32(addr, small32, 1);
   vld2_lane_s64(addr, small64, 0);
 
   vld2q_lane_s8(addr, big8, 15);
   vld2q_lane_s16(addr, big16, 7);
   vld2q_lane_s32(addr, big32, 3);
   vld2q_lane_s64(addr, big64, 1);
 
-  vld2_lane_s8(addr, small8, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld2_lane_s16(addr, small16, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld2_lane_s32(addr, small32, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vld2_lane_s64(addr, small64, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vld2q_lane_s8(addr, big8, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vld2q_lane_s16(addr, big16, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld2q_lane_s32(addr, big32, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld2q_lane_s64(addr, big64, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vld2_lane_s8(addr, small8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld2_lane_s16(addr, small16, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld2_lane_s32(addr, small32, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld2_lane_s64(addr, small64, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vld2q_lane_s8(addr, big8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld2q_lane_s16(addr, big16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld2q_lane_s32(addr, big32, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld2q_lane_s64(addr, big64, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vst2_lane_s8(addr, small8, 7);
   vst2_lane_s16(addr, small16, 3);
   vst2_lane_s32(addr, small32, 1);
   vst2_lane_s64(addr, small64, 0);
 
   vst2q_lane_s8(addr, big8, 15);
   vst2q_lane_s16(addr, big16, 7);
   vst2q_lane_s32(addr, big32, 3);
   vst2q_lane_s64(addr, big64, 1);
 
-  vst2_lane_s8(addr, small8, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst2_lane_s16(addr, small16, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst2_lane_s32(addr, small32, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vst2_lane_s64(addr, small64, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vst2q_lane_s8(addr, big8, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vst2q_lane_s16(addr, big16, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst2q_lane_s32(addr, big32, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst2q_lane_s64(addr, big64, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vst2_lane_s8(addr, small8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst2_lane_s16(addr, small16, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst2_lane_s32(addr, small32, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst2_lane_s64(addr, small64, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vst2q_lane_s8(addr, big8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst2q_lane_s16(addr, big16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst2q_lane_s32(addr, big32, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst2q_lane_s64(addr, big64, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_ld3st3(int8x8x3_t small8, int8x16x3_t big8,
                  int16x4x3_t small16, int16x8x3_t big16,
                  int32x2x3_t small32, int32x4x3_t big32,
                  int64x1x3_t small64, int64x2x3_t big64,
                  void *addr) {
   vld3_lane_s8(addr, small8, 7);
   vld3_lane_s16(addr, small16, 3);
   vld3_lane_s32(addr, small32, 1);
   vld3_lane_s64(addr, small64, 0);
 
   vld3q_lane_s8(addr, big8, 15);
   vld3q_lane_s16(addr, big16, 7);
   vld3q_lane_s32(addr, big32, 3);
   vld3q_lane_s64(addr, big64, 1);
 
-  vld3_lane_s8(addr, small8, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld3_lane_s16(addr, small16, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld3_lane_s32(addr, small32, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vld3_lane_s64(addr, small64, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vld3q_lane_s8(addr, big8, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vld3q_lane_s16(addr, big16, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld3q_lane_s32(addr, big32, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld3q_lane_s64(addr, big64, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vld3_lane_s8(addr, small8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld3_lane_s16(addr, small16, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld3_lane_s32(addr, small32, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld3_lane_s64(addr, small64, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vld3q_lane_s8(addr, big8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld3q_lane_s16(addr, big16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld3q_lane_s32(addr, big32, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld3q_lane_s64(addr, big64, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vst3_lane_s8(addr, small8, 7);
   vst3_lane_s16(addr, small16, 3);
   vst3_lane_s32(addr, small32, 1);
   vst3_lane_s64(addr, small64, 0);
 
   vst3q_lane_s8(addr, big8, 15);
   vst3q_lane_s16(addr, big16, 7);
   vst3q_lane_s32(addr, big32, 3);
   vst3q_lane_s64(addr, big64, 1);
 
-  vst3_lane_s8(addr, small8, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst3_lane_s16(addr, small16, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst3_lane_s32(addr, small32, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vst3_lane_s64(addr, small64, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vst3q_lane_s8(addr, big8, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vst3q_lane_s16(addr, big16, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst3q_lane_s32(addr, big32, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst3q_lane_s64(addr, big64, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vst3_lane_s8(addr, small8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst3_lane_s16(addr, small16, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst3_lane_s32(addr, small32, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst3_lane_s64(addr, small64, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vst3q_lane_s8(addr, big8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst3q_lane_s16(addr, big16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst3q_lane_s32(addr, big32, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst3q_lane_s64(addr, big64, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_ld4st4(int8x8x4_t small8, int8x16x4_t big8,
                  int16x4x4_t small16, int16x8x4_t big16,
                  int32x2x4_t small32, int32x4x4_t big32,
                  int64x1x4_t small64, int64x2x4_t big64,
                  void *addr) {
   vld4_lane_s8(addr, small8, 7);
   vld4_lane_s16(addr, small16, 3);
   vld4_lane_s32(addr, small32, 1);
   vld4_lane_s64(addr, small64, 0);
 
   vld4q_lane_s8(addr, big8, 15);
   vld4q_lane_s16(addr, big16, 7);
   vld4q_lane_s32(addr, big32, 3);
   vld4q_lane_s64(addr, big64, 1);
 
-  vld4_lane_s8(addr, small8, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld4_lane_s16(addr, small16, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld4_lane_s32(addr, small32, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vld4_lane_s64(addr, small64, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vld4q_lane_s8(addr, big8, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vld4q_lane_s16(addr, big16, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vld4q_lane_s32(addr, big32, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vld4q_lane_s64(addr, big64, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vld4_lane_s8(addr, small8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld4_lane_s16(addr, small16, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld4_lane_s32(addr, small32, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld4_lane_s64(addr, small64, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vld4q_lane_s8(addr, big8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld4q_lane_s16(addr, big16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld4q_lane_s32(addr, big32, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vld4q_lane_s64(addr, big64, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   vst4_lane_s8(addr, small8, 7);
   vst4_lane_s16(addr, small16, 3);
   vst4_lane_s32(addr, small32, 1);
   vst4_lane_s64(addr, small64, 0);
 
   vst4q_lane_s8(addr, big8, 15);
   vst4q_lane_s16(addr, big16, 7);
   vst4q_lane_s32(addr, big32, 3);
   vst4q_lane_s64(addr, big64, 1);
 
-  vst4_lane_s8(addr, small8, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst4_lane_s16(addr, small16, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst4_lane_s32(addr, small32, 2); // expected-error {{argument should be a value from 0 to 1}}
-  vst4_lane_s64(addr, small64, 1); // expected-error {{argument should be a value from 0 to 0}}
-
-  vst4q_lane_s8(addr, big8, 16); // expected-error {{argument should be a value from 0 to 15}}
-  vst4q_lane_s16(addr, big16, 8); // expected-error {{argument should be a value from 0 to 7}}
-  vst4q_lane_s32(addr, big32, 4); // expected-error {{argument should be a value from 0 to 3}}
-  vst4q_lane_s64(addr, big64, 2); // expected-error {{argument should be a value from 0 to 1}}
+  vst4_lane_s8(addr, small8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst4_lane_s16(addr, small16, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst4_lane_s32(addr, small32, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst4_lane_s64(addr, small64, 1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+
+  vst4q_lane_s8(addr, big8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst4q_lane_s16(addr, big16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst4q_lane_s32(addr, big32, 4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vst4q_lane_s64(addr, big64, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 

test/Sema/arm-neon-types.c

 float32x2_t test2(uint32x2_t x) {
   return vcvt_n_f32_s32(x, 9); // expected-warning {{incompatible vector types}}
 }
 
 // Check immediate range for vcvt_n intrinsics is 1 to 32.  Radar 9558930.
 float32x2_t test3(uint32x2_t x) {
   // FIXME: The "incompatible result type" error is due to pr10112 and should be
   // removed when that is fixed.
-  return vcvt_n_f32_u32(x, 0); // expected-error {{argument should be a value from 1 to 32}}
+  return vcvt_n_f32_u32(x, 0); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 typedef signed int vSInt32 __attribute__((__vector_size__(16)));
 int32x4_t test4(int32x4_t a, vSInt32 b) {
   a += b;
   b += a;
   return b += a;
 }

test/Sema/builtin-object-size.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-darwin9 -verify %s
 
 int a[10];
 
 int f0() {
   return __builtin_object_size(&a); // expected-error {{too few arguments to function}}
 }
 int f1() {
   return (__builtin_object_size(&a, 0) + 
           __builtin_object_size(&a, 1) + 
           __builtin_object_size(&a, 2) + 
           __builtin_object_size(&a, 3));
 }
 int f2() {
-  return __builtin_object_size(&a, -1); // expected-error {{argument should be a value from 0 to 3}}
+  return __builtin_object_size(&a, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
 }
 int f3() {
-  return __builtin_object_size(&a, 4); // expected-error {{argument should be a value from 0 to 3}}
+  return __builtin_object_size(&a, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
 }
 
 
 // rdar://6252231 - cannot call vsnprintf with va_list on x86_64
 void f4(const char *fmt, ...) {
  __builtin_va_list args;
  __builtin___vsnprintf_chk (0, 42, 0, 11, fmt, args); // expected-warning {{'__builtin___vsnprintf_chk' will always overflow destination buffer}}
 }
 
 // rdar://18334276
 typedef __typeof__(sizeof(int)) size_t;
 void * memcset(void *restrict dst, int src, size_t n);
 void * memcpy(void *restrict dst, const void *restrict src, size_t n);
 
 #define memset(dest, src, len) __builtin___memset_chk(dest, src, len, __builtin_object_size(dest, 0))
 #define memcpy(dest, src, len) __builtin___memcpy_chk(dest, src, len, __builtin_object_size(dest, 0))
 #define memcpy1(dest, src, len) __builtin___memcpy_chk(dest, src, len, __builtin_object_size(dest, 4))
 #define NULL ((void *)0)
 
 void f5(void)
 {
   char buf[10];
   memset((void *)0x100000000ULL, 0, 0x1000);
   memcpy((char *)NULL + 0x10000, buf, 0x10);
-  memcpy1((char *)NULL + 0x10000, buf, 0x10); // expected-error {{argument should be a value from 0 to 3}}
+  memcpy1((char *)NULL + 0x10000, buf, 0x10); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
 }
 
 // rdar://18431336
 void f6(void)
 {
   char b[5];
   char buf[10];
   __builtin___memccpy_chk (buf, b, '\0', sizeof(b), __builtin_object_size (buf, 0));

test/Sema/builtin-prefetch.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 void foo() {
   int a;
   __builtin_prefetch(&a);
   __builtin_prefetch(&a, 1);
   __builtin_prefetch(&a, 1, 2);
   __builtin_prefetch(&a, 1, 9, 3); // expected-error{{too many arguments to function}}
   __builtin_prefetch(&a, "hello", 2); // expected-error{{argument to '__builtin_prefetch' must be a constant integer}}
   __builtin_prefetch(&a, a, 2); // expected-error{{argument to '__builtin_prefetch' must be a constant integer}}
-  __builtin_prefetch(&a, 2); // expected-error{{argument should be a value from 0 to 1}}
-  __builtin_prefetch(&a, 0, 4); // expected-error{{argument should be a value from 0 to 3}}
-  __builtin_prefetch(&a, -1, 4); // expected-error{{argument should be a value from 0 to 1}}
+  __builtin_prefetch(&a, 2); // expected-error{{argument value 2 is outside the valid range [0, 1]}}
+  __builtin_prefetch(&a, 0, 4); // expected-error{{argument value 4 is outside the valid range [0, 3]}}
+  __builtin_prefetch(&a, -1, 4); // expected-error{{argument value -1 is outside the valid range [0, 1]}}
 }

test/Sema/builtins-arm.c

 
 void test2() {
   __builtin_va_list ptr = "x";
   *ptr = '0'; // expected-error {{incomplete type 'void' is not assignable}}
 }
 #endif
 
 void test3() {
-  __builtin_arm_dsb(16); // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_arm_dmb(17); // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_arm_isb(18); // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_arm_dsb(16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_dmb(17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_isb(18); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test4() {
-  __builtin_arm_prefetch(0, 2, 0); // expected-error {{argument should be a value from 0 to 1}}
-  __builtin_arm_prefetch(0, 0, 2); // expected-error {{argument should be a value from 0 to 1}}
+  __builtin_arm_prefetch(0, 2, 0); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_prefetch(0, 0, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test5() {
-  __builtin_arm_dbg(16); // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_arm_dbg(16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test6(int a, int b, int c) {
   __builtin_arm_ldc(1, 2, &a);
   __builtin_arm_ldc(a, 2, &a); // expected-error {{argument to '__builtin_arm_ldc' must be a constant integer}}
   __builtin_arm_ldc(1, a, &a); // expected-error {{argument to '__builtin_arm_ldc' must be a constant integer}}
 
   __builtin_arm_ldcl(1, 2, &a);

 
 void test_9_4_1_width_specified_saturation(int a, int b) {
   unsigned u;
   int s;
 
   s = __builtin_arm_ssat(8, 2);
   s = __builtin_arm_ssat(a, 1);
   s = __builtin_arm_ssat(a, 32);
-  s = __builtin_arm_ssat(a, 0);   // expected-error {{argument should be a value from 1 to 32}}
-  s = __builtin_arm_ssat(a, 33);  // expected-error {{argument should be a value from 1 to 32}}
+  s = __builtin_arm_ssat(a, 0);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  s = __builtin_arm_ssat(a, 33);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   s = __builtin_arm_ssat(a, b);   // expected-error {{argument to '__builtin_arm_ssat' must be a constant integer}}
 
   u = __builtin_arm_usat(8, 2);
   u = __builtin_arm_usat(a, 0);
   u = __builtin_arm_usat(a, 31);
-  u = __builtin_arm_usat(a, 32);  // expected-error {{argument should be a value from 0 to 31}}
+  u = __builtin_arm_usat(a, 32);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   u = __builtin_arm_usat(a, b);   // expected-error {{argument to '__builtin_arm_usat' must be a constant integer}}
 }
 
 void test_9_4_2_saturating_addition_subtraction(int a, int b) {
   int s;
   s = __builtin_arm_qadd(a, b);
   s = __builtin_arm_qadd(-1, 0);
 

 }
 
 void test_9_5_4_parallel_16bit_saturation(int16x2_t a) {
   unsigned u;
   int s;
 
   s = __builtin_arm_ssat16(a, 1);
   s = __builtin_arm_ssat16(a, 16);
-  s = __builtin_arm_ssat16(a, 0);  // expected-error {{argument should be a value from 1 to 16}}
-  s = __builtin_arm_ssat16(a, 17); // expected-error {{argument should be a value from 1 to 16}}
+  s = __builtin_arm_ssat16(a, 0);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  s = __builtin_arm_ssat16(a, 17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   u = __builtin_arm_usat16(a, 0);
   u = __builtin_arm_usat16(a, 15);
-  u = __builtin_arm_usat16(a, 16); // expected-error {{argument should be a value from 0 to 15}}
+  u = __builtin_arm_usat16(a, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_9_5_5_packing_and_unpacking(int16x2_t a, int8x4_t b, uint16x2_t c, uint8x4_t d) {
   int16x2_t x;
   uint16x2_t y;
 
   x = __builtin_arm_sxtab16(a, b);
   x = __builtin_arm_sxtab16(1, -1);

 }
 
 void test_VFP(float f, double d) {
   float fr;
   double dr;
 
   fr = __builtin_arm_vcvtr_f(f, 0);
   fr = __builtin_arm_vcvtr_f(f, 1);
-  fr = __builtin_arm_vcvtr_f(f, -1); // expected-error {{argument should be a value from 0 to 1}}
-  fr = __builtin_arm_vcvtr_f(f, 2);  // expected-error {{argument should be a value from 0 to 1}}
+  fr = __builtin_arm_vcvtr_f(f, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  fr = __builtin_arm_vcvtr_f(f, 2);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
 
   dr = __builtin_arm_vcvtr_f(d, 0);
   dr = __builtin_arm_vcvtr_f(d, 1);
-  dr = __builtin_arm_vcvtr_f(d, -1); // expected-error {{argument should be a value from 0 to 1}}
-  dr = __builtin_arm_vcvtr_f(d, 2);  // expected-error {{argument should be a value from 0 to 1}}
+  dr = __builtin_arm_vcvtr_f(d, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  dr = __builtin_arm_vcvtr_f(d, 2);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }

test/Sema/builtins-arm64.c

void test_clear_cache_voids(void *start, void *end) {
   __clear_cache(start, end);
 }
 
 void test_clear_cache_no_args() {
   __clear_cache(); // expected-error {{too few arguments to function call}}
 }
 
 void test_memory_barriers() {
-  __builtin_arm_dmb(16); // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_arm_dsb(17); // expected-error {{argument should be a value from 0 to 15}}
-  __builtin_arm_isb(18); // expected-error {{argument should be a value from 0 to 15}}
+  __builtin_arm_dmb(16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_dsb(17); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_isb(18); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 
 void test_prefetch() {
-  __builtin_arm_prefetch(0, 2, 0, 0, 0); // expected-error {{argument should be a value from 0 to 1}}
-  __builtin_arm_prefetch(0, 0, 3, 0, 0); // expected-error {{argument should be a value from 0 to 2}}
-  __builtin_arm_prefetch(0, 0, 0, 2, 0); // expected-error {{argument should be a value from 0 to 1}}
-  __builtin_arm_prefetch(0, 0, 0, 0, 2); // expected-error {{argument should be a value from 0 to 1}}
+  __builtin_arm_prefetch(0, 2, 0, 0, 0); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_prefetch(0, 0, 3, 0, 0); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_prefetch(0, 0, 0, 2, 0); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_arm_prefetch(0, 0, 0, 0, 2); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }

test/Sema/builtins-ppc.c

 // REQUIRES: powerpc-registered-target
 // RUN: %clang_cc1 -target-feature +altivec -target-feature +htm                       \
 // RUN: -triple powerpc64-unknown-unknown -DTEST_HTM -fsyntax-only      \
 // RUN: -verify %s
 
 // RUN: %clang_cc1 -target-feature +altivec -target-feature +crypto                    \
 // RUN: -triple powerpc64le-unknown-unknown -DTEST_CRYPTO -fsyntax-only      \
 // RUN: -verify %s
 
 #ifdef TEST_HTM
 void test_htm() {
-  __builtin_tbegin(4); // expected-error {{argument should be a value from 0 to 1}}
-  __builtin_tend(-1);  // expected-error {{argument should be a value from 0 to 1}}
-  __builtin_tsr(55);   // expected-error {{argument should be a value from 0 to 7}}
-  __builtin_tabortwc(-5, 2, 3); // expected-error {{argument should be a value from 0 to 31}} 
-  __builtin_tabortdc(55, 2, 3); // expected-error {{argument should be a value from 0 to 31}}
-  __builtin_tabortwci(-5, 2, 5); // expected-error {{argument should be a value from 0 to 31}}
-  __builtin_tabortwci(5, 2, 55); // expected-error {{argument should be a value from 0 to 31}}  
-  __builtin_tabortdci(-5, 2, 5); // expected-error {{argument should be a value from 0 to 31}}
-  __builtin_tabortdci(5, 2, 55); // expected-error {{argument should be a value from 0 to 31}}
+  __builtin_tbegin(4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_tend(-1);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_tsr(55);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_tabortwc(-5, 2, 3); // expected-error-re {{argument value {{.*}} is outside the valid range}} 
+  __builtin_tabortdc(55, 2, 3); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_tabortwci(-5, 2, 5); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_tabortwci(5, 2, 55); // expected-error-re {{argument value {{.*}} is outside the valid range}}  
+  __builtin_tabortdci(-5, 2, 5); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  __builtin_tabortdci(5, 2, 55); // expected-error-re {{argument value {{.*}} is outside the valid range}}
 }
 #endif
 
 
 #ifdef TEST_CRYPTO
 #include <altivec.h>
 
 #define W_INIT { 0x01020304, 0x05060708, 0x090A0B0C, 0x0D0E0F10 };
 #define D_INIT { 0x0102030405060708, 0x090A0B0C0D0E0F10 };
 vector unsigned int test_vshasigmaw_or(void)
 {
   vector unsigned int a = W_INIT
-  vector unsigned int b = __builtin_crypto_vshasigmaw(a, 2, 15);  // expected-error {{argument should be a value from 0 to 1}}
-  vector unsigned int c = __builtin_crypto_vshasigmaw(a, -1, 15); // expected-error {{argument should be a value from 0 to 1}}
-  vector unsigned int d = __builtin_crypto_vshasigmaw(a, 0, 85);  // expected-error {{argument should be a value from 0 to 15}}
-  vector unsigned int e = __builtin_crypto_vshasigmaw(a, 1, -15); // expected-error {{argument should be a value from 0 to 15}}
+  vector unsigned int b = __builtin_crypto_vshasigmaw(a, 2, 15);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vector unsigned int c = __builtin_crypto_vshasigmaw(a, -1, 15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vector unsigned int d = __builtin_crypto_vshasigmaw(a, 0, 85);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vector unsigned int e = __builtin_crypto_vshasigmaw(a, 1, -15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   return __builtin_crypto_vshasigmaw(a, 1, 15);
 }
 
 vector unsigned long long test_vshasigmad_or(void)
 {
   vector unsigned long long a = D_INIT
-  vector unsigned long long b = __builtin_crypto_vshasigmad(a, 2, 15);  // expected-error {{argument should be a value from 0 to 1}}
-  vector unsigned long long c = __builtin_crypto_vshasigmad(a, -1, 15); // expected-error {{argument should be a value from 0 to 1}}
-  vector unsigned long long d = __builtin_crypto_vshasigmad(a, 0, 85);  // expected-error {{argument should be a value from 0 to 1}}
-  vector unsigned long long e = __builtin_crypto_vshasigmad(a, 1, -15); // expected-error {{argument should be a value from 0 to 1}}
+  vector unsigned long long b = __builtin_crypto_vshasigmad(a, 2, 15);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vector unsigned long long c = __builtin_crypto_vshasigmad(a, -1, 15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vector unsigned long long d = __builtin_crypto_vshasigmad(a, 0, 85);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
+  vector unsigned long long e = __builtin_crypto_vshasigmad(a, 1, -15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   return __builtin_crypto_vshasigmad(a, 0, 15);
 }
 
 #endif
 

test/Sema/builtins-x86.c

 typedef unsigned int __mmask32;
 
 void call_x86_32_builtins(void) {
   (void)__builtin_ia32_readeflags_u32();                             // expected-error{{this builtin is only available on 32-bit targets}}
   (void)__builtin_ia32_writeeflags_u32(4);                           // expected-error{{this builtin is only available on 32-bit targets}}
 }
 
 __m128 test__builtin_ia32_cmpps(__m128 __a, __m128 __b) {
-  __builtin_ia32_cmpps(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}}
+  return __builtin_ia32_cmpps(__a, __b, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
 }
 
 __m128d test__builtin_ia32_cmppd(__m128d __a, __m128d __b) {
-  __builtin_ia32_cmppd(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}}
+  return __builtin_ia32_cmppd(__a, __b, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
 }
 
 __m128 test__builtin_ia32_cmpss(__m128 __a, __m128 __b) {
-  __builtin_ia32_cmpss(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}}
+  return __builtin_ia32_cmpss(__a, __b, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
 }
 
 __m128d test__builtin_ia32_cmpsd(__m128d __a, __m128d __b) {
-  __builtin_ia32_cmpsd(__a, __b, 32); // expected-error {{argument should be a value from 0 to 31}}
+  return __builtin_ia32_cmpsd(__a, __b, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
 }
 
 __mmask16 test__builtin_ia32_cmpps512_mask(__m512d __a, __m512d __b) {
-  __builtin_ia32_cmpps512_mask(__a, __b, 32, -1, 4); // expected-error {{argument should be a value from 0 to 31}}
+  return __builtin_ia32_cmpps512_mask(__a, __b, 32, -1, 4); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
 }
 
 __mmask8 test__builtin_ia32_cmppd512_mask(__m512d __a, __m512d __b) {
-  __builtin_ia32_cmppd512_mask(__a, __b, 32, -1, 4); // expected-error {{argument should be a value from 0 to 31}}
+  return __builtin_ia32_cmppd512_mask(__a, __b, 32, -1, 4); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
 }
 
 __m128i test__builtin_ia32_vpcomub(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomub(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomub(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __m128i test__builtin_ia32_vpcomuw(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomuw(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomuw(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __m128i test__builtin_ia32_vpcomud(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomud(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomud(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __m128i test__builtin_ia32_vpcomuq(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomuq(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomuq(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __m128i test__builtin_ia32_vpcomb(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomub(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomub(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __m128i test__builtin_ia32_vpcomw(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomuw(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomuw(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __m128i test__builtin_ia32_vpcomd(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomud(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomud(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __m128i test__builtin_ia32_vpcomq(__m128i __a, __m128i __b) {
-  __builtin_ia32_vpcomuq(__a, __b, 8); // expected-error {{argument should be a value from 0 to 7}}
+  return __builtin_ia32_vpcomuq(__a, __b, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
 }
 
 __mmask16 test__builtin_ia32_cmpps512_mask_rounding(__m512 __a, __m512 __b, __mmask16 __u) {
-  __builtin_ia32_cmpps512_mask(__a, __b, 0, __u, 0); // expected-error {{invalid rounding argument}}
+  return __builtin_ia32_cmpps512_mask(__a, __b, 0, __u, 0); // expected-error {{invalid rounding argument}}
 }
 
 __m128i test_mm_mask_i32gather_epi32(__m128i a, int const *b, __m128i c, __m128i mask) {
   return __builtin_ia32_gatherd_d(a, b, c, mask, 5); // expected-error {{scale argument must be 1, 2, 4, or 8}}
 }
 
-__m512i _mm512_mask_prefetch_i32gather_ps(__m512i index, __mmask16 mask, int const *addr) {
-  return __builtin_ia32_gatherpfdps(mask, index, addr, 5, 1); // expected-error {{scale argument must be 1, 2, 4, or 8}}
+void _mm512_mask_prefetch_i32gather_ps(__m512i index, __mmask16 mask, int const *addr) {
+  __builtin_ia32_gatherpfdps(mask, index, addr, 5, 1); // expected-error {{scale argument must be 1, 2, 4, or 8}}
 }
 
-__m512 _mm512_mask_prefetch_i32gather_ps_2(__m512i index, __mmask16 mask, int const *addr) {
-  return __builtin_ia32_gatherpfdps(mask, index, addr, 1, 1); // expected-error {{argument should be a value from 2 to 3}}
+void _mm512_mask_prefetch_i32gather_ps_2(__m512i index, __mmask16 mask, int const *addr) {
+  __builtin_ia32_gatherpfdps(mask, index, addr, 1, 1); // expected-error {{argument value 1 is outside the valid range [2, 3]}}
 }
 
 __m512i test_mm512_shldi_epi64(__m512i __A, __m512i __B) {
-  return __builtin_ia32_vpshldq512(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldq512(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m512i test_mm512_shldi_epi32(__m512i __A, __m512i __B) {
-  return __builtin_ia32_vpshldd512(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldd512(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m512i test_mm512_shldi_epi16(__m512i __A, __m512i __B) {
-  return __builtin_ia32_vpshldw512(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldw512(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m512i test_mm512_shrdi_epi64(__m512i __A, __m512i __B) {
-  return __builtin_ia32_vpshrdq512(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdq512(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m512i test_mm512_shrdi_epi32(__m512i __A, __m512i __B) {
-  return __builtin_ia32_vpshrdd512(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdd512(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m512i test_mm512_shrdi_epi16(__m512i __A, __m512i __B) {
-  return __builtin_ia32_vpshrdw512(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdw512(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m256i test_mm256_shldi_epi64(__m256i __A, __m256i __B) {
-  return __builtin_ia32_vpshldq256(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldq256(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m128i test_mm128_shldi_epi64( __m128i __A, __m128i __B) {
-  return __builtin_ia32_vpshldq128(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldq128(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m256i test_mm256_shldi_epi32(__m256i __A, __m256i __B) {
-  return __builtin_ia32_vpshldd256(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldd256(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m128i test_mm128_shldi_epi32(__m128i __A, __m128i __B) {
-  return __builtin_ia32_vpshldd128(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldd128(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m256i test_mm256_shldi_epi16( __m256i __A, __m256i __B) {
-  return __builtin_ia32_vpshldw256(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldw256(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m128i test_mm128_shldi_epi16(__m128i __A, __m128i __B) {
-  return __builtin_ia32_vpshldw128(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshldw128(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m256i test_mm256_shrdi_epi64(__m256i __A, __m256i __B) {
-  return __builtin_ia32_vpshrdq256(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdq256(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m128i test_mm128_shrdi_epi64(__m128i __A, __m128i __B) {
-  return __builtin_ia32_vpshrdq128(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdq128(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m256i test_mm256_shrdi_epi32(__m256i __A, __m256i __B) {
-  return __builtin_ia32_vpshrdd256(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdd256(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m128i test_mm128_shrdi_epi32(__m128i __A, __m128i __B) {
-  return __builtin_ia32_vpshrdd128(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdd128(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m256i test_mm256_shrdi_epi16(__m256i __A, __m256i __B) {
-  return __builtin_ia32_vpshrdw256(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdw256(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }
 
 __m128i test_mm128_shrdi_epi16(__m128i __A, __m128i __B) {
-  return __builtin_ia32_vpshrdw128(__A, __B, 1024); // expected-error {{argument should be a value from 0 to 255}}
+  return __builtin_ia32_vpshrdw128(__A, __B, 1024); // expected-error {{argument value 1024 is outside the valid range [0, 255]}}
 }

test/Sema/builtins-x86.cpp

+// RUN: %clang_cc1 -triple=x86_64-apple-darwin -fsyntax-only -verify %s
+//
+// Ensure that when we use builtins in C++ code with templates that compute the
+// valid immediate, the dead code with the invalid immediate doesn't error.
+
+typedef short __v8hi __attribute__((__vector_size__(16)));
+
+template <int Imm>
+__v8hi test(__v8hi a) {
+    if (Imm < 4)
+      return __builtin_ia32_pshuflw(a, 0x55 * Imm);
+    else
+      return __builtin_ia32_pshuflw(a, 0x55 * (Imm - 4));
+}
+
+template __v8hi test<0>(__v8hi);
+template __v8hi test<1>(__v8hi);
+template __v8hi test<2>(__v8hi);
+template __v8hi test<3>(__v8hi);
+template __v8hi test<4>(__v8hi);
+template __v8hi test<5>(__v8hi);
+template __v8hi test<6>(__v8hi);
+template __v8hi test<7>(__v8hi);
 No newline at end of file

test/SemaCXX/neon-vector-types.cpp

namespace rdar11688587 {
   typedef __attribute__((neon_vector_type(4))) float32_t float32x4_t;
 
   template<int I>
   float test()
   {
     extern float32x4_t vec;
     return __extension__ ({ 
         float32x4_t __a = (vec); 
-        (float32_t)__builtin_neon_vgetq_lane_f32(__a, I);  // expected-error{{argument should be a value from 0 to 3}}
+        (float32_t)__builtin_neon_vgetq_lane_f32(__a, I);  // expected-error-re{{argument value {{.*}} is outside the valid range}}
       });
   }
 
   template float test<1>();
   template float test<4>(); // expected-note{{in instantiation of function template specialization 'rdar11688587::test<4>' requested here}}
 }