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

dead code.

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.

Differential Revision: https://reviews.llvm.org/D48464

llvm-svn: 335309

6 files changed, 112 insertions, 112 deletions

diff --git a/clang/test/CodeGen/builtins-mips-args.c b/clang/test/CodeGen/builtins-mips-args.c
index fd3e31443ec..cdb42af4a53 100644
--- a/clang/test/CodeGen/builtins-mips-args.c
+++ b/clang/test/CodeGen/builtins-mips-args.c
@@ -7,10 +7,10 @@ void foo() {
   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
 
@@ -20,18 +20,18 @@ void foo() {
   __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}}
 }
diff --git a/clang/test/CodeGen/builtins-systemz-vector-error.c b/clang/test/CodeGen/builtins-systemz-vector-error.c
index 6f4ecc2acad..f0db9010827 100644
--- a/clang/test/CodeGen/builtins-systemz-vector-error.c
+++ b/clang/test/CodeGen/builtins-systemz-vector-error.c
@@ -27,148 +27,148 @@ 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}}
 }
diff --git a/clang/test/CodeGen/builtins-systemz-vector2-error.c b/clang/test/CodeGen/builtins-systemz-vector2-error.c
index ceebaf8cc72..cd27ac79e15 100644
--- a/clang/test/CodeGen/builtins-systemz-vector2-error.c
+++ b/clang/test/CodeGen/builtins-systemz-vector2-error.c
@@ -28,34 +28,34 @@ 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}}
 }
diff --git a/clang/test/CodeGen/builtins-systemz-zvector-error.c b/clang/test/CodeGen/builtins-systemz-zvector-error.c
index 8d5aaabfbac..cb60ea495ec 100644
--- a/clang/test/CodeGen/builtins-systemz-zvector-error.c
+++ b/clang/test/CodeGen/builtins-systemz-zvector-error.c
@@ -560,6 +560,6 @@ void test_float(void) {
                            // 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}}
 }
diff --git a/clang/test/CodeGen/builtins-systemz-zvector2-error.c b/clang/test/CodeGen/builtins-systemz-zvector2-error.c
index 823d6374dc0..3b890b9d09a 100644
--- a/clang/test/CodeGen/builtins-systemz-zvector2-error.c
+++ b/clang/test/CodeGen/builtins-systemz-zvector2-error.c
@@ -127,8 +127,8 @@ void test_integer(void) {
                                 // 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) {
diff --git a/clang/test/CodeGen/hexagon-check-builtins.c b/clang/test/CodeGen/hexagon-check-builtins.c
index 97118d5ead8..a9294362f6b 100644
--- a/clang/test/CodeGen/hexagon-check-builtins.c
+++ b/clang/test/CodeGen/hexagon-check-builtins.c
@@ -2,13 +2,13 @@
 // 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);
@@ -17,13 +17,13 @@ int foo(int x) {
 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);
 }