[Clang 15.0.1] Downgrade implicit int and implicit function declaration to warning only

[aaron.ballman]

Summary

The changes in Clang 15.0.0 which enabled these diagnostics as a warning which defaulted to an error caused disruption for people working on distributions such as Gentoo. There was an explicit request to downgrade these to be warning-only in Clang 15.0.1 with the expectation that Clang 16 will default the diagnostics to an error.

See https://discourse.llvm.org/t/configure-script-breakage-with-the-new-werror-implicit-function-declaration/65213 for more details on the discussion.

[aaron.ballman]

@thieta and @tstellar -- because these changes are expected to go into the 15.0.1 branch, not the current main branch, it wasn't clear to me what the best way to go about the review (whether I should submit a Phab request or make a fork of Clang and submit a GitHub pull request), but given the tight schedule I put this up as a Phab review that we can hopefully validate quickly. I'd appreciate some help getting this tested on more configurations though, as precommit CI won't be able to run on these changes to inform me of what tests I missed because I'm on Windows.

[thieta]

I think the easiest way to handle this is that when you have it approved here - push it to fork on GitHub based on the release branch and create a GitHub issue and write /branch aballman/llvm-project/my_branch in a comment and it will queue up the cherry pick.

[aaron.ballman]

In D133800#3787378, @thieta wrote:

I think the easiest way to handle this is that when you have it approved here - push it to fork on GitHub based on the release branch and create a GitHub issue and write /branch aballman/llvm-project/my_branch in a comment and it will queue up the cherry pick.

Thanks for the suggestion, I'll do that once we have agreement here.

Adding in more reviewers for greater visibility.

[jyknight]

Looks correct to me.

[mgorny]

Thanks for doing this. I'm going to test it in 2-3 hours and get back to you.

[mgorny]

I'm seeing test failures with this patch applied:

Failed Tests (3):
  Clang :: CodeGen/PowerPC/builtins-ppc-p8vector.c
  Clang :: CodeGen/builtins-arm-msvc-compat-only.c
  Clang :: CodeGen/neon-crypto.c

Overall, they all look like they were relying on the -Werror=... behavior.

Test failure details:

tests.txt20 KBDownload

[mgorny]

Hmm, I just realized that I've tested on top of 15.0.0. If commits already on top of release/15.x branch already fix that, I'm sorry!

[nikic]

I tested this patch as well and saw the same failures as @mgorny. Here's the additional patch I had to apply to make this pass:

diff --git a/clang/test/CodeGen/PowerPC/builtins-ppc-p8vector.c b/clang/test/CodeGen/PowerPC/builtins-ppc-p8vector.c
index af3d5c7d066b..54d2c70c0aa5 100644
--- a/clang/test/CodeGen/PowerPC/builtins-ppc-p8vector.c
+++ b/clang/test/CodeGen/PowerPC/builtins-ppc-p8vector.c
@@ -143,7 +143,7 @@ void test1() {
   res_vui = vec_mergee(vui, vui);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
-// CHECK-PPC: error: call to undeclared function 'vec_mergee'
+// CHECK-PPC: warning: call to undeclared function 'vec_mergee'
 
   res_vbll = vec_mergee(vbll, vbll);
 // CHECK: @llvm.ppc.altivec.vperm
@@ -177,7 +177,7 @@ void test1() {
   res_vui = vec_mergeo(vui, vui);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
-// CHECK-PPC: error: call to undeclared function 'vec_mergeo'
+// CHECK-PPC: warning: call to undeclared function 'vec_mergeo'
 
   /* vec_cmpeq */
   res_vbll = vec_cmpeq(vbll, vbll);
@@ -403,7 +403,7 @@ void test1() {
   res_vsc = vec_cntlz(vsc);
 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
 // CHECK-LE: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
-// CHECK-PPC: error: call to undeclared function 'vec_cntlz'
+// CHECK-PPC: warning: call to undeclared function 'vec_cntlz'
 
   res_vuc = vec_cntlz(vuc);
 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
@@ -754,19 +754,19 @@ void test1() {
   res_vsi = vec_vpksdss(vsll, vsll);
 // CHECK: llvm.ppc.altivec.vpksdss
 // CHECK-LE: llvm.ppc.altivec.vpksdss
-// CHECK-PPC: error: call to undeclared function 'vec_vpksdss'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpksdss'
 
   /* vec_vpksdus */
   res_vui = vec_vpksdus(vsll, vsll);
 // CHECK: llvm.ppc.altivec.vpksdus
 // CHECK-LE: llvm.ppc.altivec.vpksdus
-// CHECK-PPC: error: call to undeclared function 'vec_vpksdus'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpksdus'
 
   /* vec_vpkudum */
   res_vsi = vec_vpkudum(vsll, vsll);
 // CHECK: vperm
 // CHECK-LE: vperm
-// CHECK-PPC: error: call to undeclared function 'vec_vpkudum'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpkudum'
 
   res_vui = vec_vpkudum(vull, vull);
 // CHECK: vperm
@@ -775,13 +775,13 @@ void test1() {
   res_vui = vec_vpkudus(vull, vull);
 // CHECK: llvm.ppc.altivec.vpkudus
 // CHECK-LE: llvm.ppc.altivec.vpkudus
-// CHECK-PPC: error: call to undeclared function 'vec_vpkudus'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpkudus'
 
   /* vec_vupkhsw */
   res_vsll = vec_vupkhsw(vsi);
 // CHECK: llvm.ppc.altivec.vupkhsw
 // CHECK-LE: llvm.ppc.altivec.vupklsw
-// CHECK-PPC: error: call to undeclared function 'vec_vupkhsw'
+// CHECK-PPC: warning: call to undeclared function 'vec_vupkhsw'
 
   res_vbll = vec_vupkhsw(vbi);
 // CHECK: llvm.ppc.altivec.vupkhsw
@@ -791,7 +791,7 @@ void test1() {
   res_vsll = vec_vupklsw(vsi);
 // CHECK: llvm.ppc.altivec.vupklsw
 // CHECK-LE: llvm.ppc.altivec.vupkhsw
-// CHECK-PPC: error: call to undeclared function 'vec_vupklsw'
+// CHECK-PPC: warning: call to undeclared function 'vec_vupklsw'
 
   res_vbll = vec_vupklsw(vbi);
 // CHECK: llvm.ppc.altivec.vupklsw
@@ -845,7 +845,7 @@ void test1() {
 // CHECK: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK-LE: [[T1:%.+]] = and <16 x i8>
 // CHECK-LE: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-PPC: error: call to undeclared function 'vec_nand'
+// CHECK-PPC: warning: call to undeclared function 'vec_nand'
 
   res_vbc = vec_nand(vbc, vbc);
 // CHECK: [[T1:%.+]] = and <16 x i8>
@@ -937,7 +937,7 @@ void test1() {
 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
-// CHECK-PPC: error: call to undeclared function 'vec_orc'
+// CHECK-PPC: warning: call to undeclared function 'vec_orc'
 
   res_vsc = vec_orc(vsc, vbc);
 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
@@ -1166,7 +1166,7 @@ void test1() {
   res_vsll = vec_vbpermq(vuc, vuc);
 // CHECK: llvm.ppc.altivec.vbpermq
 // CHECK-LE: llvm.ppc.altivec.vbpermq
-// CHECK-PPC: error: call to undeclared function 'vec_vbpermq'
+// CHECK-PPC: warning: call to undeclared function 'vec_vbpermq'
 
   /* vec_vgbbd */
   res_vsc = vec_vgbbd(vsc);
@@ -1176,12 +1176,12 @@ void test1() {
   res_vuc = vec_vgbbd(vuc);
 // CHECK: llvm.ppc.altivec.vgbbd
 // CHECK-LE: llvm.ppc.altivec.vgbbd
-// CHECK-PPC: error: call to undeclared function 'vec_vgbbd'
+// CHECK-PPC: warning: call to undeclared function 'vec_vgbbd'
 
   res_vuc = vec_gb(vuc);
 // CHECK: llvm.ppc.altivec.vgbbd
 // CHECK-LE: llvm.ppc.altivec.vgbbd
-// CHECK-PPC: error: call to undeclared function 'vec_gb'
+// CHECK-PPC: warning: call to undeclared function 'vec_gb'
 
   res_vsll = vec_gbb(vsll);
 // CHECK: llvm.ppc.altivec.vgbbd
diff --git a/clang/test/CodeGen/builtins-arm-msvc-compat-only.c b/clang/test/CodeGen/builtins-arm-msvc-compat-only.c
index 42cc9d70a142..c2b021b31174 100644
--- a/clang/test/CodeGen/builtins-arm-msvc-compat-only.c
+++ b/clang/test/CodeGen/builtins-arm-msvc-compat-only.c
@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -triple thumbv7-windows -fms-extensions -emit-llvm -o - %s \
 // RUN:     | FileCheck %s -check-prefix CHECK-MSVC
-// RUN: not %clang_cc1 -triple armv7-eabi -emit-llvm %s -o /dev/null 2>&1 \
+// RUN: %clang_cc1 -triple armv7-eabi -emit-llvm %s -o /dev/null 2>&1 \
 // RUN:     | FileCheck %s -check-prefix CHECK-EABI
 // REQUIRES: arm-registered-target
 
@@ -9,7 +9,7 @@ void emit() {
 }
 
 // CHECK-MSVC: call void asm sideeffect ".inst.n 0xDEFE", ""()
-// CHECK-EABI: error: call to undeclared function '__emit'
+// CHECK-EABI: warning: call to undeclared function '__emit'
 
 void emit_truncated() {
   __emit(0x11110000); // movs r0, r0
diff --git a/clang/test/CodeGen/neon-crypto.c b/clang/test/CodeGen/neon-crypto.c
index 916886574416..1b29b1a53096 100644
--- a/clang/test/CodeGen/neon-crypto.c
+++ b/clang/test/CodeGen/neon-crypto.c
@@ -14,7 +14,7 @@
 
 uint8x16_t test_vaeseq_u8(uint8x16_t data, uint8x16_t key) {
   // CHECK-LABEL: @test_vaeseq_u8
-  // CHECK-NO-CRYPTO: error: call to undeclared function 'vaeseq_u8'
+  // CHECK-NO-CRYPTO: warning: call to undeclared function 'vaeseq_u8'
   return vaeseq_u8(data, key);
   // CHECK: call <16 x i8> @llvm.{{arm.neon|aarch64.crypto}}.aese(<16 x i8> %data, <16 x i8> %key)
 }

[mgorny]

@nikic, with your patch I still have CodeGen/PowerPC/builtins-ppc-p8vector.c failing.

[nikic]

@mgorny Yeah, that was a testing fail on my side. I've updated it to a hopefully correct version.

[aaron.ballman]

Updated the failing tests caught during review (thank you!) and moved the release notes around and reworded them somewhat for clarity.

[aaron.ballman]

In D133800#3788950, @nikic wrote:

I tested this patch as well and saw the same failures as @mgorny.

Thank you, I think I've got those patched up, but with one difference:

<snip>
diff --git a/clang/test/CodeGen/neon-crypto.c b/clang/test/CodeGen/neon-crypto.c
index 916886574416..1b29b1a53096 100644
--- a/clang/test/CodeGen/neon-crypto.c
+++ b/clang/test/CodeGen/neon-crypto.c
@@ -14,7 +14,7 @@
 
 uint8x16_t test_vaeseq_u8(uint8x16_t data, uint8x16_t key) {
   // CHECK-LABEL: @test_vaeseq_u8
-  // CHECK-NO-CRYPTO: error: call to undeclared function 'vaeseq_u8'
+  // CHECK-NO-CRYPTO: warning: call to undeclared function 'vaeseq_u8'
   return vaeseq_u8(data, key);
   // CHECK: call <16 x i8> @llvm.{{arm.neon|aarch64.crypto}}.aese(<16 x i8> %data, <16 x i8> %key)
 }

Because this was the only error in the file, I changed the RUN line to remove the not in front of %clang_cc1, as that seemed like it would be necessary to get the test to pass as well.

[mgorny]

In D133800#3788983, @nikic wrote:

@mgorny Yeah, that was a testing fail on my side. I've updated it to a hopefully correct version.

Ok, thanks. This version worked for me.

[mgorny]

In D133800#3789100, @aaron.ballman wrote:

In D133800#3788950, @nikic wrote:

I tested this patch as well and saw the same failures as @mgorny.

Thank you, I think I've got those patched up, but with one difference:

<snip>
diff --git a/clang/test/CodeGen/neon-crypto.c b/clang/test/CodeGen/neon-crypto.c
index 916886574416..1b29b1a53096 100644
--- a/clang/test/CodeGen/neon-crypto.c
+++ b/clang/test/CodeGen/neon-crypto.c
@@ -14,7 +14,7 @@
 
 uint8x16_t test_vaeseq_u8(uint8x16_t data, uint8x16_t key) {
   // CHECK-LABEL: @test_vaeseq_u8
-  // CHECK-NO-CRYPTO: error: call to undeclared function 'vaeseq_u8'
+  // CHECK-NO-CRYPTO: warning: call to undeclared function 'vaeseq_u8'
   return vaeseq_u8(data, key);
   // CHECK: call <16 x i8> @llvm.{{arm.neon|aarch64.crypto}}.aese(<16 x i8> %data, <16 x i8> %key)
 }

Because this was the only error in the file, I changed the RUN line to remove the not in front of %clang_cc1, as that seemed like it would be necessary to get the test to pass as well.

I'm afraid this version fails:

FAIL: Clang :: CodeGen/neon-crypto.c (4802 of 15654)
******************** TEST 'Clang :: CodeGen/neon-crypto.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm-none-linux-gnueabi -target-feature +neon   -target-feature +sha2 -target-feature +aes   -target-cpu cortex-a57 -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c | /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
: 'RUN: at line 5';   /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon    -target-feature +sha2 -target-feature +aes    -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c | /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
: 'RUN: at line 8';   /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon    -S -O3 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c 2>&1 | /usr/lib/llvm/15/bin/FileCheck --check-prefix=CHECK-NO-CRYPTO /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
--
Exit Code: 1

Command Output (stderr):
--
+ : 'RUN: at line 1'
+ /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm-none-linux-gnueabi -target-feature +neon -target-feature +sha2 -target-feature +aes -target-cpu cortex-a57 -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ : 'RUN: at line 5'
+ /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon -target-feature +sha2 -target-feature +aes -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ : 'RUN: at line 8'
+ /usr/lib/llvm/15/bin/FileCheck --check-prefix=CHECK-NO-CRYPTO /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon -S -O3 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c

--

********************

[aaron.ballman]

In D133800#3789188, @mgorny wrote:

In D133800#3789100, @aaron.ballman wrote:

In D133800#3788950, @nikic wrote:

I tested this patch as well and saw the same failures as @mgorny.

Thank you, I think I've got those patched up, but with one difference:

<snip>
diff --git a/clang/test/CodeGen/neon-crypto.c b/clang/test/CodeGen/neon-crypto.c
index 916886574416..1b29b1a53096 100644
--- a/clang/test/CodeGen/neon-crypto.c
+++ b/clang/test/CodeGen/neon-crypto.c
@@ -14,7 +14,7 @@
 
 uint8x16_t test_vaeseq_u8(uint8x16_t data, uint8x16_t key) {
   // CHECK-LABEL: @test_vaeseq_u8
-  // CHECK-NO-CRYPTO: error: call to undeclared function 'vaeseq_u8'
+  // CHECK-NO-CRYPTO: warning: call to undeclared function 'vaeseq_u8'
   return vaeseq_u8(data, key);
   // CHECK: call <16 x i8> @llvm.{{arm.neon|aarch64.crypto}}.aese(<16 x i8> %data, <16 x i8> %key)
 }

Because this was the only error in the file, I changed the RUN line to remove the not in front of %clang_cc1, as that seemed like it would be necessary to get the test to pass as well.

I'm afraid this version fails:

FAIL: Clang :: CodeGen/neon-crypto.c (4802 of 15654)
******************** TEST 'Clang :: CodeGen/neon-crypto.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm-none-linux-gnueabi -target-feature +neon   -target-feature +sha2 -target-feature +aes   -target-cpu cortex-a57 -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c | /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
: 'RUN: at line 5';   /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon    -target-feature +sha2 -target-feature +aes    -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c | /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
: 'RUN: at line 8';   /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon    -S -O3 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c 2>&1 | /usr/lib/llvm/15/bin/FileCheck --check-prefix=CHECK-NO-CRYPTO /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
--
Exit Code: 1

Command Output (stderr):
--
+ : 'RUN: at line 1'
+ /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm-none-linux-gnueabi -target-feature +neon -target-feature +sha2 -target-feature +aes -target-cpu cortex-a57 -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ : 'RUN: at line 5'
+ /usr/lib/llvm/15/bin/FileCheck /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon -target-feature +sha2 -target-feature +aes -emit-llvm -O1 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ : 'RUN: at line 8'
+ /usr/lib/llvm/15/bin/FileCheck --check-prefix=CHECK-NO-CRYPTO /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c
+ /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/clang -cc1 -internal-isystem /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/x/y/clang-abi_x86_32.x86/bin/../../../../lib/clang/15.0.0/include -nostdsysteminc -triple arm64-none-linux-gnu -target-feature +neon -S -O3 -o - /var/tmp/portage/sys-devel/clang-15.0.0-r1/work/clang/test/CodeGen/neon-crypto.c

--

********************

Thanks for letting me know, I'll switch it back to include the not but... that's a surprise. It looks like it's been that way for ~9 years though.

[aaron.ballman]

Added the not back into the neon-crypto.c test.

[mgorny]

The newest version looks good. Thanks!

[aaron.ballman]

In D133800#3787378, @thieta wrote:

I think the easiest way to handle this is that when you have it approved here - push it to fork on GitHub based on the release branch and create a GitHub issue and write /branch aballman/llvm-project/my_branch in a comment and it will queue up the cherry pick.

I've filed https://github.com/llvm/llvm-project/issues/57739 and assigned it to you @thieta -- please let me know if I've mucked something up!

[aaron.ballman]

In D133800#3789377, @aaron.ballman wrote:

In D133800#3787378, @thieta wrote:

I think the easiest way to handle this is that when you have it approved here - push it to fork on GitHub based on the release branch and create a GitHub issue and write /branch aballman/llvm-project/my_branch in a comment and it will queue up the cherry pick.

I've filed https://github.com/llvm/llvm-project/issues/57739 and assigned it to you @thieta -- please let me know if I've mucked something up!

And that was landed in https://github.com/llvm/llvm-project-release-prs/commit/c0141f3c300fbc002cf79404fa0b82b4cb1191df so this review can now be closed. Thank you for the quick turnaround on getting me review feedback!

clang/docs/ReleaseNotes.rst

 What's New in Clang |release|?
 ==============================
 
 Some of the major new features and improvements to Clang are listed
 here. Generic improvements to Clang as a whole or to its underlying
 infrastructure are described first, followed by language-specific
 sections with improvements to Clang's support for those languages.
 
+Potentially Breaking Changes
+============================
+These changes are ones which we think may surprise users when upgrading to
+Clang |release| because of the opportunity they pose for disruption to existing
+code bases.
+
+- The ``-Wimplicit-function-declaration`` and ``-Wimplicit-int`` warning
+  diagnostics are now enabled by default in C99, C11, and C17. As of C2x,
+  support for implicit function declarations and implicit int has been removed,
+  and the warning options will have no effect. Specifying ``-Wimplicit-int`` in
+  C89 mode will now issue warnings instead of being a noop.
+  *NOTE* these warnings are expected to default to an error in Clang 16. We
+  recommend that projects using configure scripts verify the results do not
+  change before/after setting ``-Werror=implicit-function-declarations`` or
+  ``-Wimplicit-int`` to avoid incompatibility with Clang 16.
+
 Major New Features
 ------------------
 
 - Clang now supports the ``-fzero-call-used-regs`` feature for x86. The purpose
   of this feature is to limit Return-Oriented Programming (ROP) exploits and
   information leakage. It works by zeroing out a selected class of registers
   before function return --- e.g., all GPRs that are used within the function.
   There is an analogous ``zero_call_used_regs`` attribute to allow for finer
- Modified the behavior of ``-Wstrict-prototypes`` and added a new, related
   disable the diagnostic for all callers at the point of declaration. This
   diagnostic is grouped under the ``-Wstrict-prototypes`` warning group, but is
   enabled by default. ``-Wdeprecated-non-prototype`` has no effect in C2x or
   when ``-fno-knr-functions`` is enabled.
 - Clang now appropriately issues an error in C when a definition of a function
   without a prototype and with no arguments is an invalid redeclaration of a
   function with a prototype. e.g., ``void f(int); void f() {}`` is now properly
   diagnosed.
-- The ``-Wimplicit-function-declaration`` warning diagnostic now defaults to
-  an error in C99 and later. Prior to C2x, it may be downgraded to a warning
-  with ``-Wno-error=implicit-function-declaration``, or disabled entirely with
-  ``-Wno-implicit-function-declaration``. As of C2x, support for implicit
-  function declarations has been removed, and the warning options will have no
-  effect.
-- The ``-Wimplicit-int`` warning diagnostic now defaults to an error in C99 and
-  later. Prior to C2x, it may be downgraded to a warning with
-  ``-Wno-error=implicit-int``, or disabled entirely with ``-Wno-implicit-int``.
-  As of C2x, support for implicit int has been removed, and the warning options
-  will have no effect. Specifying ``-Wimplicit-int`` in C89 mode will now issue
-  warnings instead of being a noop.
 - No longer issue a "declaration specifiers missing, defaulting to int"
   diagnostic in C89 mode because it is not an extension in C89, it was valid
   code. The diagnostic has been removed entirely as it did not have a
   diagnostic group to disable it, but it can be covered wholly by
   ``-Wimplicit-int``.
 - ``-Wmisexpect`` warns when the branch weights collected during profiling
   conflict with those added by ``llvm.expect``.
 - ``-Wthread-safety-analysis`` now considers overloaded compound assignment and

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_return_value_udt_incomplete: Warning<
   "%0 has C-linkage specified, but returns incomplete type %1 which could be "
   "incompatible with C">, InGroup<ReturnTypeCLinkage>;
 def warn_implicit_function_decl : Warning<
   "implicit declaration of function %0">,
   InGroup<ImplicitFunctionDeclare>, DefaultIgnore;
 def ext_implicit_function_decl_c99 : ExtWarn<
   "call to undeclared function %0; ISO C99 and later do not support implicit "
-  "function declarations">, InGroup<ImplicitFunctionDeclare>, DefaultError;
+  "function declarations">, InGroup<ImplicitFunctionDeclare>;
 def note_function_suggestion : Note<"did you mean %0?">;
 
 def err_ellipsis_first_param : Error<
   "ISO C requires a named parameter before '...'">;
 def err_declarator_need_ident : Error<"declarator requires an identifier">;
 def err_language_linkage_spec_unknown : Error<"unknown linkage language">;
 def err_language_linkage_spec_not_ascii : Error<
   "string literal in language linkage specifier cannot have an "

 
 /// Built-in functions.
 def ext_implicit_lib_function_decl : ExtWarn<
   "implicitly declaring library function '%0' with type %1">,
   InGroup<ImplicitFunctionDeclare>;
 def ext_implicit_lib_function_decl_c99 : ExtWarn<
   "call to undeclared library function '%0' with type %1; ISO C99 and later "
   "do not support implicit function declarations">,
-  InGroup<ImplicitFunctionDeclare>, DefaultError;
+  InGroup<ImplicitFunctionDeclare>;
 def note_include_header_or_declare : Note<
   "include the header <%0> or explicitly provide a declaration for '%1'">;
 def note_previous_builtin_declaration : Note<"%0 is a builtin with type %1">;
 def warn_implicit_decl_no_jmp_buf
     : Warning<"declaration of built-in function '%0' requires the declaration"
     " of the 'jmp_buf' type, commonly provided in the header <setjmp.h>.">,
       InGroup<DiagGroup<"incomplete-setjmp-declaration">>;
 def warn_implicit_decl_requires_sysheader : Warning<

 def err_void_only_param : Error<
   "'void' must be the first and only parameter if specified">;
 def err_void_param_qualified : Error<
   "'void' as parameter must not have type qualifiers">;
 def err_ident_list_in_fn_declaration : Error<
   "a parameter list without types is only allowed in a function definition">;
 def ext_param_not_declared : ExtWarn<
   "parameter %0 was not declared, defaults to 'int'; ISO C99 and later do not "
-  "support implicit int">, InGroup<ImplicitInt>, DefaultError;
+  "support implicit int">, InGroup<ImplicitInt>;
 def err_param_default_argument : Error<
   "C does not support default arguments">;
 def err_param_default_argument_redefinition : Error<
   "redefinition of default argument">;
 def ext_param_default_argument_redefinition : ExtWarn<
   err_param_default_argument_redefinition.Text>,
   InGroup<MicrosoftDefaultArgRedefinition>;
 def err_param_default_argument_missing : Error<

 def ext_wchar_t_sign_spec : ExtWarn<"'%0' cannot be signed or unsigned">,
   InGroup<DiagGroup<"signed-unsigned-wchar">>, DefaultError;
 def warn_receiver_forward_class : Warning<
   "receiver %0 is a forward class and corresponding @interface may not exist">,
   InGroup<ForwardClassReceiver>;
 def note_method_sent_forward_class : Note<"method %0 is used for the forward class">;
 def ext_missing_type_specifier : ExtWarn<
   "type specifier missing, defaults to 'int'; ISO C99 and later do not support "
-  "implicit int">, InGroup<ImplicitInt>, DefaultError;
+  "implicit int">, InGroup<ImplicitInt>;
 def err_missing_type_specifier : Error<
   "a type specifier is required for all declarations">;
 def err_decimal_unsupported : Error<
   "GNU decimal type extension not supported">;
 def err_objc_array_of_interfaces : Error<
   "array of interface %0 is invalid (probably should be an array of pointers)">;
 def ext_c99_array_usage : Extension<
   "%select{qualifier in |static |}0array size %select{||'[*] '}0is a C99 "

clang/test/C/drs/dr0xx.c

 
 /* WG14 DR009: no
  * Use of typedef names in parameter declarations
  *
  * FIXME: This should be diagnosed as expecting a declaration specifier instead
  * of treated as declaring a parameter of type 'int (*)(dr009_t);'
  */
 typedef int dr009_t;
-void dr009_f((dr009_t)); /* c99untilc2x-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
+void dr009_f((dr009_t)); /* c99untilc2x-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
                             c2xandup-error {{a type specifier is required for all declarations}} */
 
 /* WG14 DR010:
  * Is a typedef to an incomplete type legal?
  */
 typedef int dr010_t[];
 dr010_t dr010_a = {1};
 dr010_t dr010_b = {1, 2};

clang/test/C/drs/dr1xx.c

 
 /* WG14 DR163: yes
  * Undeclared identifiers
  */
 void dr163(void) {
   int i;
   i = undeclared; /* expected-error {{use of undeclared identifier 'undeclared'}} */
   sdfsdfsf = 1;   /* expected-error {{use of undeclared identifier 'sdfsdfsf'}} */
-  i = also_undeclared(); /* c99untilc2x-error {{call to undeclared function 'also_undeclared'; ISO C99 and later do not support implicit function declarations}}
+  i = also_undeclared(); /* c99untilc2x-warning {{call to undeclared function 'also_undeclared'; ISO C99 and later do not support implicit function declarations}}
                             c2xandup-error {{use of undeclared identifier 'also_undeclared'}}
                           */
 }
 
 /* WG14 DR164: yes
  * Bad declarations
  */
 void dr164(void) {
   int a [][5];    /* expected-error {{definition of variable with array type needs an explicit size or an initializer}} */
   int x, b [][5]; /* expected-error {{definition of variable with array type needs an explicit size or an initializer}} */
 }

clang/test/CodeGen/PowerPC/builtins-ppc-p8vector.c

// CHECK-LE: @llvm.ppc.altivec.vperm
 
   res_vsi = vec_mergee(vsi, vsi);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
 
   res_vui = vec_mergee(vui, vui);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
-// CHECK-PPC: error: call to undeclared function 'vec_mergee'
+// CHECK-PPC: warning: call to undeclared function 'vec_mergee'
 
   res_vbll = vec_mergee(vbll, vbll);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
 
   res_vsll = vec_mergee(vsll, vsll);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
// CHECK-LE: @llvm.ppc.altivec.vperm
 
   res_vsi = vec_mergeo(vsi, vsi);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
 
   res_vui = vec_mergeo(vui, vui);
 // CHECK: @llvm.ppc.altivec.vperm
 // CHECK-LE: @llvm.ppc.altivec.vperm
-// CHECK-PPC: error: call to undeclared function 'vec_mergeo'
+// CHECK-PPC: warning: call to undeclared function 'vec_mergeo'
 
   /* vec_cmpeq */
   res_vbll = vec_cmpeq(vbll, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpequd
 // CHECK-LE: @llvm.ppc.altivec.vcmpequd
 
   res_vbll = vec_cmpeq(vsll, vsll);
 // CHECK: @llvm.ppc.altivec.vcmpequd
// CHECK-LE: insertelement <2 x i64>
   res_vd = vec_insert(d, vda, si);
 // CHECK: insertelement <2 x double>
 // CHECK-LE: insertelement <2 x double>
 
   /* vec_cntlz */
   res_vsc = vec_cntlz(vsc);
 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
 // CHECK-LE: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
-// CHECK-PPC: error: call to undeclared function 'vec_cntlz'
+// CHECK-PPC: warning: call to undeclared function 'vec_cntlz'
 
   res_vuc = vec_cntlz(vuc);
 // CHECK: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
 // CHECK-LE: call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %{{.+}}, i1 false)
 
   res_vss = vec_cntlz(vss);
 // CHECK: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false)
 // CHECK-LE: call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %{{.+}}, i1 false)

 // CHECK: llvm.ppc.altivec.vupklsw
 // CHECK-LE: llvm.ppc.altivec.vupkhsw
 // CHECK-PPC: error: call to 'vec_unpackl' is ambiguous
 
   /* vec_vpksdss */
   res_vsi = vec_vpksdss(vsll, vsll);
 // CHECK: llvm.ppc.altivec.vpksdss
 // CHECK-LE: llvm.ppc.altivec.vpksdss
-// CHECK-PPC: error: call to undeclared function 'vec_vpksdss'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpksdss'
 
   /* vec_vpksdus */
   res_vui = vec_vpksdus(vsll, vsll);
 // CHECK: llvm.ppc.altivec.vpksdus
 // CHECK-LE: llvm.ppc.altivec.vpksdus
-// CHECK-PPC: error: call to undeclared function 'vec_vpksdus'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpksdus'
 
   /* vec_vpkudum */
   res_vsi = vec_vpkudum(vsll, vsll);
 // CHECK: vperm
 // CHECK-LE: vperm
-// CHECK-PPC: error: call to undeclared function 'vec_vpkudum'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpkudum'
 
   res_vui = vec_vpkudum(vull, vull);
 // CHECK: vperm
 // CHECK-LE: vperm
 
   res_vui = vec_vpkudus(vull, vull);
 // CHECK: llvm.ppc.altivec.vpkudus
 // CHECK-LE: llvm.ppc.altivec.vpkudus
-// CHECK-PPC: error: call to undeclared function 'vec_vpkudus'
+// CHECK-PPC: warning: call to undeclared function 'vec_vpkudus'
 
   /* vec_vupkhsw */
   res_vsll = vec_vupkhsw(vsi);
 // CHECK: llvm.ppc.altivec.vupkhsw
 // CHECK-LE: llvm.ppc.altivec.vupklsw
-// CHECK-PPC: error: call to undeclared function 'vec_vupkhsw'
+// CHECK-PPC: warning: call to undeclared function 'vec_vupkhsw'
 
   res_vbll = vec_vupkhsw(vbi);
 // CHECK: llvm.ppc.altivec.vupkhsw
 // CHECK-LE: llvm.ppc.altivec.vupklsw
 
   /* vec_vupklsw */
   res_vsll = vec_vupklsw(vsi);
 // CHECK: llvm.ppc.altivec.vupklsw
 // CHECK-LE: llvm.ppc.altivec.vupkhsw
-// CHECK-PPC: error: call to undeclared function 'vec_vupklsw'
+// CHECK-PPC: warning: call to undeclared function 'vec_vupklsw'
 
   res_vbll = vec_vupklsw(vbi);
 // CHECK: llvm.ppc.altivec.vupklsw
 // CHECK-LE: llvm.ppc.altivec.vupkhsw
 
   /* vec_max */
   res_vsll = vec_max(vsll, vsll);
 // CHECK: @llvm.ppc.altivec.vmaxsd

 // CHECK-LE: @llvm.ppc.altivec.vminud
 
   /* vec_nand */
   res_vsc = vec_nand(vsc, vsc);
 // CHECK: [[T1:%.+]] = and <16 x i8>
 // CHECK: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK-LE: [[T1:%.+]] = and <16 x i8>
 // CHECK-LE: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
-// CHECK-PPC: error: call to undeclared function 'vec_nand'
+// CHECK-PPC: warning: call to undeclared function 'vec_nand'
 
   res_vbc = vec_nand(vbc, vbc);
 // CHECK: [[T1:%.+]] = and <16 x i8>
 // CHECK: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK-LE: [[T1:%.+]] = and <16 x i8>
 // CHECK-LE: xor <16 x i8> [[T1]], <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 
   res_vuc = vec_nand(vuc, vuc);

 // CHECK-LE: xor <4 x i32> [[T1]], <i32 -1, i32 -1, i32 -1, i32 -1>
 
   /* vec_orc */
   res_vsc = vec_orc(vsc, vsc);
 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
-// CHECK-PPC: error: call to undeclared function 'vec_orc'
+// CHECK-PPC: warning: call to undeclared function 'vec_orc'
 
   res_vsc = vec_orc(vsc, vbc);
 // CHECK: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK: or <16 x i8> {{%.+}}, [[T1]]
 // CHECK-LE: [[T1:%.+]] = xor <16 x i8> {{%.+}}, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 // CHECK-LE: or <16 x i8> {{%.+}}, [[T1]]
 
   res_vsc = vec_orc(vbc, vsc);
// CHECK-LE: sub <1 x i128>
   /* vec_vbpermq */
   res_vsll = vec_vbpermq(vsc, vsc);
 // CHECK: llvm.ppc.altivec.vbpermq
 // CHECK-LE: llvm.ppc.altivec.vbpermq
 
   res_vsll = vec_vbpermq(vuc, vuc);
 // CHECK: llvm.ppc.altivec.vbpermq
 // CHECK-LE: llvm.ppc.altivec.vbpermq
-// CHECK-PPC: error: call to undeclared function 'vec_vbpermq'
+// CHECK-PPC: warning: call to undeclared function 'vec_vbpermq'
 
   /* vec_vgbbd */
   res_vsc = vec_vgbbd(vsc);
 // CHECK: llvm.ppc.altivec.vgbbd
 // CHECK-LE: llvm.ppc.altivec.vgbbd
 
   res_vuc = vec_vgbbd(vuc);
 // CHECK: llvm.ppc.altivec.vgbbd
 // CHECK-LE: llvm.ppc.altivec.vgbbd
-// CHECK-PPC: error: call to undeclared function 'vec_vgbbd'
+// CHECK-PPC: warning: call to undeclared function 'vec_vgbbd'
 
   res_vuc = vec_gb(vuc);
 // CHECK: llvm.ppc.altivec.vgbbd
 // CHECK-LE: llvm.ppc.altivec.vgbbd
-// CHECK-PPC: error: call to undeclared function 'vec_gb'
+// CHECK-PPC: warning: call to undeclared function 'vec_gb'
 
   res_vsll = vec_gbb(vsll);
 // CHECK: llvm.ppc.altivec.vgbbd
 // CHECK-LE: llvm.ppc.altivec.vgbbd
 
   res_vull = vec_gbb(vull);
 // CHECK: llvm.ppc.altivec.vgbbd
 // CHECK-LE: llvm.ppc.altivec.vgbbd

clang/test/CodeGen/builtins-arm-msvc-compat-only.c

 // RUN: %clang_cc1 -triple thumbv7-windows -fms-extensions -emit-llvm -o - %s \
 // RUN:     | FileCheck %s -check-prefix CHECK-MSVC
-// RUN: not %clang_cc1 -triple armv7-eabi -emit-llvm %s -o /dev/null 2>&1 \
+// RUN: %clang_cc1 -triple armv7-eabi -emit-llvm %s -o /dev/null 2>&1 \
 // RUN:     | FileCheck %s -check-prefix CHECK-EABI
 // REQUIRES: arm-registered-target
 
 void emit() {
   __emit(0xdefe);
 }
 
 // CHECK-MSVC: call void asm sideeffect ".inst.n 0xDEFE", ""()
-// CHECK-EABI: error: call to undeclared function '__emit'
+// CHECK-EABI: warning: call to undeclared function '__emit'
 
 void emit_truncated() {
   __emit(0x11110000); // movs r0, r0
 }
 
 // CHECK-MSVC: call void asm sideeffect ".inst.n 0x0", ""()
 

clang/test/CodeGen/neon-crypto.c

 // RUN: %clang_cc1 -triple arm-none-linux-gnueabi -target-feature +neon \
 // RUN:  -target-feature +sha2 -target-feature +aes \
 // RUN:  -target-cpu cortex-a57 -emit-llvm -O1 -o - %s | FileCheck %s
 
 // RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon \
 // RUN:   -target-feature +sha2 -target-feature +aes \
 // RUN:   -emit-llvm -O1 -o - %s | FileCheck %s
 // RUN: not %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon \
 // RUN:   -S -O3 -o - %s 2>&1 | FileCheck --check-prefix=CHECK-NO-CRYPTO %s
 
 // REQUIRES: aarch64-registered-target || arm-registered-target
 
 #include <arm_neon.h>
 
 uint8x16_t test_vaeseq_u8(uint8x16_t data, uint8x16_t key) {
   // CHECK-LABEL: @test_vaeseq_u8
-  // CHECK-NO-CRYPTO: error: call to undeclared function 'vaeseq_u8'
+  // CHECK-NO-CRYPTO: warning: call to undeclared function 'vaeseq_u8'
   return vaeseq_u8(data, key);
   // CHECK: call <16 x i8> @llvm.{{arm.neon|aarch64.crypto}}.aese(<16 x i8> %data, <16 x i8> %key)
 }
 
 uint8x16_t test_vaesdq_u8(uint8x16_t data, uint8x16_t key) {
   // CHECK-LABEL: @test_vaesdq_u8
   return vaesdq_u8(data, key);
   // CHECK: call <16 x i8> @llvm.{{arm.neon|aarch64.crypto}}.aesd(<16 x i8> %data, <16 x i8> %key)

clang/test/Driver/cxx_for_opencl.clcpp

 // RUN: %clang %s -Xclang -verify -fsyntax-only
 // RUN: %clang %s -cl-std=clc++ -Xclang -verify -fsyntax-only
 // RUN: %clang %s -cl-std=cl2.0 -Xclang -verify -fsyntax-only
 // RUN: %clang %s -### 2>&1 | FileCheck %s
 
 // CHECK: "-x" "clcpp"
 
 #ifdef __OPENCL_CPP_VERSION__
 //expected-no-diagnostics
 #endif
 
 kernel void k(){
   auto a = get_local_id(1);
 #ifndef __OPENCL_CPP_VERSION__
 //expected-error@-2{{OpenCL C version 2.0 does not support the 'auto' storage class specifier}}
-//expected-error@-3{{type specifier missing, defaults to 'int'}}
+//expected-warning@-3{{type specifier missing, defaults to 'int'}}
 #endif
 }

clang/test/FixIt/fixit.c

 // CHECK: struct s s0 = { .y = 5 };
 struct s s0 = { y: 5 }; // expected-warning {{GNU old-style}}
 
 // CHECK: int array0[5] = { [3] = 3 };
 int array0[5] = { [3] 3 }; // expected-warning {{GNU 'missing ='}}
 
 // CHECK: int x
 // CHECK: int y
-void f1(x, y) // expected-error 2{{was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
+void f1(x, y) // expected-warning 2{{was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
 {
 }
 
 int i0 = { 17 };
 
 #define ONE 1
 #define TWO 2
 

clang/test/Frontend/fixed_point_errors.c

void CheckSuffixOnIntegerLiterals(void) {
   long_fract_int = 0x10lr;  // expected-error{{invalid suffix 'lr' on integer constant}}
 
   u_short_fract_int = 0x10uhr; // expected-error{{invalid suffix 'uhr' on integer constant}}
   u_fract_int = 0x10ur;        // expected-error{{invalid suffix 'ur' on integer constant}}
   u_long_fract_int = 0x10ulr;  // expected-error{{invalid suffix 'ulr' on integer constant}}
 
   // Using auto
   auto auto_fract = 0r;  // expected-error{{invalid suffix 'r' on integer constant}}
-                         // expected-error@-1{{type specifier missing, defaults to 'int'}}
+                         // expected-warning@-1{{type specifier missing, defaults to 'int'}}
   auto auto_accum = 0k;  // expected-error{{invalid suffix 'k' on integer constant}}
-                         // expected-error@-1{{type specifier missing, defaults to 'int'}}
+                         // expected-warning@-1{{type specifier missing, defaults to 'int'}}
 }
 
 // Ok conversions
 int i_const = -2.5hk;
 _Sat short _Accum sat_sa_const2 = 256.0k;
 _Sat unsigned short _Accum sat_usa_const = -1.0hk;
 short _Accum sa_const3 = 2;
 short _Accum sa_const4 = -2;

clang/test/Frontend/fixed_point_not_enabled.c

 // RUN: %clang_cc1 -x c -verify %s
 
 // Primary fixed point types
 signed short _Accum s_short_accum;    // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 signed _Accum s_accum;                // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 signed long _Accum s_long_accum;      // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 unsigned short _Accum u_short_accum;  // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 unsigned _Accum u_accum;              // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 unsigned long _Accum u_long_accum;    // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 
 // Aliased fixed point types
 short _Accum short_accum;             // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 _Accum accum;                         // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
-                                      // expected-error@-1{{type specifier missing, defaults to 'int'}}
+                                      // expected-warning@-1{{type specifier missing, defaults to 'int'}}
 long _Accum long_accum;               // expected-error{{compile with '-ffixed-point' to enable fixed point types}}
 
 // Cannot use fixed point suffixes
 int accum_int = 10k;     // expected-error{{invalid suffix 'k' on integer constant}}
 int fract_int = 10r;     // expected-error{{invalid suffix 'r' on integer constant}}
 float accum_flt = 10.0k; // expected-error{{invalid suffix 'k' on floating constant}}
 float fract_flt = 10.0r; // expected-error{{invalid suffix 'r' on floating constant}}

clang/test/Frontend/system-header-line-directive.c

 // RUN: %clang_cc1 -Wall %s -I %S/Inputs -isystem %S/Inputs/SystemHeaderPrefix -verify
 // RUN: %clang_cc1 %s -E -o - -I %S/Inputs -isystem %S/Inputs/SystemHeaderPrefix | FileCheck %s
 #include <noline.h>
 #include <line-directive-in-system.h>
 
-// expected-error@line-directive.h:* {{type specifier missing, defaults to 'int'}}
+// expected-warning@line-directive.h:* {{type specifier missing, defaults to 'int'}}
 #include "line-directive.h"
 
 // This tests that "#line" directives in system headers preserve system
 // header-ness just like GNU line markers that don't have filenames.  This was
 // PR30752.
 
 // CHECK: # {{[0-9]+}} "{{.*}}system-header-line-directive.c" 2
 // CHECK: # 1 "{{.*}}noline.h" 1 3

clang/test/Headers/arm-cmse-header-ns.c

-// RUN: not %clang_cc1 -triple thumbv8m.base-eabi -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK-c %s
+// RUN: %clang_cc1 -triple thumbv8m.base-eabi -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK-c %s
 // RUN: not %clang_cc1 -triple thumbv8m.base-eabi -fsyntax-only -x c++ %s 2>&1 | FileCheck --check-prefix=CHECK-cpp %s
 
 #include <arm_cmse.h>
 
 typedef void (*callback_t)(void);
 
 void func(callback_t fptr, void *p)
 {
   cmse_TT(p);
   cmse_TTT(p);
   cmse_TT_fptr(fptr);
   cmse_TTT_fptr(fptr);
 
   cmse_TTA(p);
   cmse_TTAT(p);
   cmse_TTA_fptr(fptr);
   cmse_TTAT_fptr(fptr);
-// CHECK-c: error: call to undeclared function 'cmse_TTA'
-// CHECK-c: error: call to undeclared function 'cmse_TTAT'
-// CHECK-c: error: call to undeclared function 'cmse_TTA_fptr'
-// CHECK-c: error: call to undeclared function 'cmse_TTAT_fptr'
+// CHECK-c: warning: call to undeclared function 'cmse_TTA'
+// CHECK-c: warning: call to undeclared function 'cmse_TTAT'
+// CHECK-c: warning: call to undeclared function 'cmse_TTA_fptr'
+// CHECK-c: warning: call to undeclared function 'cmse_TTAT_fptr'
 // CHECK-cpp: error: use of undeclared identifier 'cmse_TTA'
 // CHECK-cpp: error: use of undeclared identifier 'cmse_TTAT'
 // CHECK-cpp: error: use of undeclared identifier 'cmse_TTA_fptr'
 // CHECK-cpp: error: use of undeclared identifier 'cmse_TTAT_fptr'
 }

clang/test/Modules/config_macros.m

 @import config;
 
 int *test_foo(void) {
   return foo();
 }
 
 char *test_bar(void) {
-  return bar(); // expected-error{{call to undeclared function 'bar'; ISO C99 and later do not support implicit function declarations}} \
+  return bar(); // expected-warning{{call to undeclared function 'bar'; ISO C99 and later do not support implicit function declarations}} \
                 // expected-error{{incompatible integer to pointer conversion}}
 }
 
 #undef WANT_FOO // expected-note{{macro was #undef'd here}}
 @import config; // expected-warning{{#undef of configuration macro 'WANT_FOO' has no effect on the import of 'config'; pass '-UWANT_FOO' on the command line to configure the module}}
 
 #define WANT_FOO 2 // expected-note{{macro was defined here}}
 @import config; // expected-warning{{definition of configuration macro 'WANT_FOO' has no effect on the import of 'config'; pass '-DWANT_FOO=...' on the command line to configure the module}}

clang/test/Modules/malformed-overload.m

 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fsyntax-only -I%S/Inputs/malformed-overload -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Wno-strict-prototypes -verify %s
-NSLog(@"%@", path); // expected-error {{expected parameter declarator}} expected-error {{expected ')'}} expected-error {{type specifier missing}} expected-warning {{incompatible redeclaration}} expected-note {{to match this '('}} expected-note {{'NSLog' is a builtin with type}}
+NSLog(@"%@", path); // expected-error {{expected parameter declarator}} expected-error {{expected ')'}} expected-warning {{type specifier missing}} expected-warning {{incompatible redeclaration}} expected-note {{to match this '('}} expected-note {{'NSLog' is a builtin with type}}
 #import "X.h"
 
 @class NSString;
 void f(NSString *a) {
  NSLog(@"***** failed to get URL for %@", a);
 }

clang/test/Modules/modulemap-locations.m

 // RUN: rm -rf %t 
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/ModuleMapLocations/Module_ModuleMap -I %S/Inputs/ModuleMapLocations/Both -F %S/Inputs/ModuleMapLocations -I %S/Inputs/ModuleMapLocations -F %S/Inputs -x objective-c -fsyntax-only %s -verify -Wno-private-module
 
 // regular
 @import module_modulemap;
 @import both;
 // framework
 @import Module_ModuleMap_F;
 @import Module_ModuleMap_F.Private;
 @import Both_F;
 @import Inferred;
 
 void test(void) {
   will_be_found1();
-  wont_be_found1(); // expected-error{{call to undeclared function 'wont_be_found1'; ISO C99 and later do not support implicit function declarations}} \
-                       expected-note {{did you mean 'will_be_found1'?}} \
-                       expected-note@Inputs/ModuleMapLocations/Module_ModuleMap/a.h:1 {{'will_be_found1' declared here}}
+  wont_be_found1(); // expected-warning{{call to undeclared function 'wont_be_found1'; ISO C99 and later do not support implicit function declarations}}
   will_be_found2();
-  wont_be_found2(); // expected-error{{call to undeclared function 'wont_be_found2'; ISO C99 and later do not support implicit function declarations}}
+  wont_be_found2(); // expected-warning{{call to undeclared function 'wont_be_found2'; ISO C99 and later do not support implicit function declarations}}
 }

clang/test/OpenMP/declare_mapper_messages.c

 #pragma omp declare mapper(id: struct vec v) map(v.len) allocate(v)   // expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp declare mapper'}}
       struct vec vv, v1;
       struct vec arr[10];
       double d;
 #pragma omp target map(mapper)                                          // expected-error {{use of undeclared identifier 'mapper'}}
       {}
 #pragma omp target map(mapper:vv)                                       // expected-error {{expected '(' after 'mapper'}}
       {}
-#pragma omp target map(mapper( :vv)                                     // expected-error {{expected expression}} expected-error {{expected ')'}} expected-error {{call to undeclared function 'mapper'}} expected-note {{to match this '('}}
+#pragma omp target map(mapper( :vv)                                     // expected-error {{expected expression}} expected-error {{expected ')'}} expected-warning {{call to undeclared function 'mapper'}} expected-note {{to match this '('}}
       {}
-#pragma omp target map(mapper(aa :vv)                                   // expected-error {{use of undeclared identifier 'aa'}} expected-error {{expected ')'}} expected-error {{call to undeclared function 'mapper'}} expected-note {{to match this '('}}
+#pragma omp target map(mapper(aa :vv)                                   // expected-error {{use of undeclared identifier 'aa'}} expected-error {{expected ')'}} expected-warning {{call to undeclared function 'mapper'}} expected-note {{to match this '('}}
       {}
 #pragma omp target map(mapper(ab) :vv)                                  // expected-error {{missing map type}} expected-error {{cannot find a valid user-defined mapper for type 'struct vec' with name 'ab'}}
       {}
 #pragma omp target map(mapper(ab) :arr[0:2])                            // expected-error {{missing map type}} expected-error {{cannot find a valid user-defined mapper for type 'struct vec' with name 'ab'}}
       {}
 #pragma omp target map(mapper(aa) :vv)                                  // expected-error {{missing map type}}
       {}
 #pragma omp target map(mapper(aa) to:d)                                 // expected-error {{mapper type must be of struct, union or class type}}

clang/test/PCH/chain-macro-override.c

 // Test this without pch.
 // RUN: %clang_cc1 -include %S/Inputs/chain-macro-override1.h -include %S/Inputs/chain-macro-override2.h -fsyntax-only -verify -detailed-preprocessing-record %s
 
 // Test with pch.
 // RUN: %clang_cc1 -emit-pch -o %t1 %S/Inputs/chain-macro-override1.h -detailed-preprocessing-record
 // RUN: %clang_cc1 -emit-pch -o %t2 %S/Inputs/chain-macro-override2.h -include-pch %t1 -detailed-preprocessing-record
 // RUN: %clang_cc1 -include-pch %t2 -fsyntax-only -verify %s
 
 int foo(void) {
   f();
   g();
   h();
-  h2(); // expected-error {{call to undeclared function 'h2'; ISO C99 and later do not support implicit function declarations}}
+  h2(); // expected-warning {{call to undeclared function 'h2'; ISO C99 and later do not support implicit function declarations}}
   h3();
   return x;
 }

clang/test/Parser/altivec.c

vector signed long int v_sli;       // nonaix-warning {{Use of 'long' with '__vector' is deprecated}}
                                     // novsx-error@-2 {{cannot use 'long' with '__vector'}}
 vector unsigned long int v_uli;     // nonaix-warning {{Use of 'long' with '__vector' is deprecated}}
                                     // aix-error@-1 {{cannot use 'long' with '__vector'}}
                                     // novsx-error@-2 {{cannot use 'long' with '__vector'}}
 
 // These should have warnings.
 __vector long double  vv_ld;        // expected-error {{cannot use 'long double' with '__vector'}}
 vector long double  v_ld;           // expected-error {{cannot use 'long double' with '__vector'}}
-vector bool v_b;                    // expected-error {{type specifier missing, defaults to 'int'}}
-vector __bool v___b;                // expected-error {{type specifier missing, defaults to 'int'}}
+vector bool v_b;                    // expected-warning {{type specifier missing, defaults to 'int'}}
+vector __bool v___b;                // expected-warning {{type specifier missing, defaults to 'int'}}
 
 // These should have errors.
 #ifndef __VSX__
 __vector double vv_d1;               // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
 vector double v_d2;                  // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
 __vector bool long long v_bll1;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 __vector __bool long long v_bll2;    // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
 vector bool long long v_bll3;        // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}

clang/test/Parser/attributes.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s -pedantic -std=c99 -Wno-strict-prototypes
 
 int __attribute__(()) x;
 
 __inline void __attribute__((__always_inline__, __nodebug__))
 foo(void) {
 }
 
 
-__attribute__(()) y;   // expected-error {{type specifier missing, defaults to 'int'}}
+__attribute__(()) y;   // expected-warning {{type specifier missing, defaults to 'int'}}
 
 // PR2796
 int (__attribute__(()) *z)(long y);
 
 
 void f1(__attribute__(()) int x);
 
 int f2(y, __attribute__(()) x);     // expected-error {{expected identifier}}
 
 // This is parsed as a normal argument list (with two args that are implicit
 // int) because the __attribute__ is a declspec.
-void f3(__attribute__(()) x,  // expected-error {{type specifier missing, defaults to 'int'}}
-        y);               // expected-error {{type specifier missing, defaults to 'int'}}
+void f3(__attribute__(()) x,  // expected-warning {{type specifier missing, defaults to 'int'}}
+        y);               // expected-warning {{type specifier missing, defaults to 'int'}}
 
 void f4(__attribute__(()));   // expected-error {{expected parameter declarator}}
 
 
 // This is ok, the __attribute__ applies to the pointer.
 int baz(int (__attribute__(()) *x)(long y));
 
 void g1(void (*f1)(__attribute__(()) int x));
 void g2(int (*f2)(y, __attribute__(()) x));    // expected-error {{expected identifier}}
-void g3(void (*f3)(__attribute__(()) x, int y));  // expected-error {{type specifier missing, defaults to 'int'}}
+void g3(void (*f3)(__attribute__(()) x, int y));  // expected-warning {{type specifier missing, defaults to 'int'}}
 void g4(void (*f4)(__attribute__(())));  // expected-error {{expected parameter declarator}}
 
 
 void (*h1)(void (*f1)(__attribute__(()) int x));
 void (*h2)(int (*f2)(y, __attribute__(()) x));    // expected-error {{expected identifier}}
 
-void (*h3)(void (*f3)(__attribute__(()) x));   // expected-error {{type specifier missing, defaults to 'int'}}
+void (*h3)(void (*f3)(__attribute__(()) x));   // expected-warning {{type specifier missing, defaults to 'int'}}
 void (*h4)(void (*f4)(__attribute__(())));  // expected-error {{expected parameter declarator}}
 
 
 
 // rdar://6131260
 int foo42(void) {
   int x, __attribute__((unused)) y, z;
   return 0;

clang/test/Parser/declarators.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -std=c99
 
 extern int a1[];
 
 void f0(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
 void f1(int [*]);
 void f2(int [const *]);
 void f3(int [volatile const*]);
-int f4(*XX)(void); /* expected-error {{cannot return}} expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} */
+int f4(*XX)(void); /* expected-error {{cannot return}} expected-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} */
 int f5(int [static]); /* expected-error {{'static' may not be used without an array size}} */
 
 char ((((*X))));
 
 void (*signal(int, void (*)(int)))(int);
 
 int aaaa, ***C, * const D, B(int);
 
float *test7(void) {
   // allows us to diagnose other bad things done with y, such as this.
   return &b.y;   // expected-warning {{incompatible pointer types returning 'int *' from a function with result type 'float *'}}
 }
 
 struct xyz test8(void) { return a; }  // a should be be marked invalid, no diag.
 
 
 // Verify that implicit int still works.
-static f;      // expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
-static g = 4;  // expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
-static h        // expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
+static f;      // expected-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
+static g = 4;  // expected-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
+static h        // expected-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
       __asm__("foo");
 
 
 struct test9 {
   int x  // expected-error {{expected ';' at end of declaration list}}
   int y;
   int z  // expected-warning {{expected ';' at end of declaration list}}
 };

clang/test/Parser/objc-forcollection-neg-2.m

 @end
 
 @interface MyList (BasicTest)
 - (void)compilerTestAgainst;
 @end
 
 @implementation MyList (BasicTest)
 - (void)compilerTestAgainst {
-    static i;// expected-error {{type specifier missing, defaults to 'int'}}
+    static i;// expected-warning {{type specifier missing, defaults to 'int'}}
         for (id el, elem in self)  // expected-error {{only one element declaration is allowed}}
            ++i;
         for (id el in self) 
            ++i;
   MyList<P> ***p;
         for (p in self)  // expected-error {{selector element type 'MyList<P> ***' is not a valid object}}
            ++i;
 
 }
 @end
 

clang/test/Preprocessor/macro_paste_msextensions.c

 
 // CHECK: int baz
 // CHECK: ;
 
 
 // rdar://8197149 - VC++ allows invalid token pastes: (##baz
 #define foo(x) abc(x)
 #define bar(y) foo(##baz(y))
-bar(q) // expected-error {{type specifier missing}} expected-error {{invalid preprocessing token}} expected-error {{parameter list without types}}
+bar(q) // expected-warning {{type specifier missing}} expected-error {{invalid preprocessing token}} expected-error {{parameter list without types}}
 
 // CHECK: abc(baz(q))
 
 
 #define str(x) #x
 #define collapse_spaces(a, b, c, d) str(a ## - ## b ## - ## c ## d)
 collapse_spaces(1a, b2, 3c, d4) // expected-error 4 {{invalid preprocessing token}} expected-error {{expected function body}}
 
 // CHECK: "1a-b2-3cd4"

clang/test/Sema/__try.c

 
 void TEST(void) {
   __try {
 
   }
 }  // expected-error{{expected '__except' or '__finally' block}}
 
 void TEST(void) {
-  __except (FilterExpression()) { // expected-error{{call to undeclared function '__except'; ISO C99 and later do not support implicit function declarations}} \
+  __except (FilterExpression()) { // expected-warning{{call to undeclared function '__except'; ISO C99 and later do not support implicit function declarations}} \
     // expected-error{{too few arguments to function call, expected 1, have 0}} \
     // expected-error{{expected ';' after expression}}
   }
 }
 
 void TEST(void) {
   __finally { } // expected-error{{}}
 }

clang/test/Sema/aarch64-tme-errors.c

 // RUN: %clang_cc1 -triple aarch64-eabi -verify %s
 
 #include "arm_acle.h"
 
 void test_no_tme_funcs(void) {
-  __tstart();         // expected-error{{call to undeclared function '__tstart'; ISO C99 and later do not support implicit function declarations}}
+  __tstart();         // expected-warning{{call to undeclared function '__tstart'; ISO C99 and later do not support implicit function declarations}}
   __builtin_tstart(); // expected-error{{use of unknown builtin '__builtin_tstart'}}
 }

clang/test/Sema/address_spaces.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify
 
 #define _AS1 __attribute__((address_space(1)))
 #define _AS2 __attribute__((address_space(2)))
 #define _AS3 __attribute__((address_space(3)))
 
 void bar(_AS2 int a); // expected-error {{parameter may not be qualified with an address space}}
 
 void foo(_AS3 float *a,
          _AS1 float b) // expected-error {{parameter may not be qualified with an address space}}
 {
-  _AS2 *x;// expected-error {{type specifier missing, defaults to 'int'}}
+  _AS2 *x;// expected-warning {{type specifier missing, defaults to 'int'}}
   _AS1 float * _AS2 *B;
 
   int _AS1 _AS2 *Y;   // expected-error {{multiple address spaces specified for type}}
   int *_AS1 _AS2 *Z;  // expected-error {{multiple address spaces specified for type}}
   int *_AS1 _AS1 *M;  // expected-warning {{multiple identical address spaces specified for type}}
 
   _AS1 int local;     // expected-error {{automatic variable qualified with an address space}}
   _AS1 int array[5];  // expected-error {{automatic variable qualified with an address space}}

clang/test/Sema/auto-type.c

void Issue53652(void) {
   volatile __auto_type vat = a;
   volatile __auto_type pvat = &a;
   restrict __auto_type rat = &a;
   _Atomic __auto_type aat1 = a;
   _Atomic __auto_type paat = &a;
 
   // GCC does not accept this either, for the same reason.
   _Atomic(__auto_type) aat2 = a; // expected-error {{'__auto_type' not allowed here}} \
-                                 // expected-error {{type specifier missing, defaults to 'int'}}
+                                 // expected-warning {{type specifier missing, defaults to 'int'}}
 
   // Ensure the types are what we expect them to be, regardless of order we
   // pass the types.
   _Static_assert(__builtin_types_compatible_p(__typeof(cat), const int), "");
   _Static_assert(__builtin_types_compatible_p(const int, __typeof(cat)), "");
   _Static_assert(__builtin_types_compatible_p(__typeof(pcat), int *const), "");
   _Static_assert(__builtin_types_compatible_p(int *const, __typeof(pcat)), "");
   _Static_assert(__builtin_types_compatible_p(__typeof(vat), volatile int), "");

clang/test/Sema/bitfield.c

 typedef __typeof__(+(t5.n++)) Unsigned; // Post-increment is underspecified, but seems to
 typedef __typeof__(+(t5.n--)) Unsigned; // also act like compound-assignment.
 
 struct Test6 {
   : 0.0; // expected-error{{type name requires a specifier or qualifier}}
 };
 
 struct PR36157 {
-  int n : 1 ? 1 : implicitly_declare_function(); // expected-error {{call to undeclared function 'implicitly_declare_function'; ISO C99 and later do not support implicit function declarations}}
+  int n : 1 ? 1 : implicitly_declare_function(); // expected-warning {{call to undeclared function 'implicitly_declare_function'; ISO C99 and later do not support implicit function declarations}}
 };

clang/test/Sema/block-args.c

 // radar 7528255
 void f0(void) {
   ^(int, double d, char) {}(1, 1.34, 'a'); // expected-warning {{omitting the parameter name in a function definition is a C2x extension}} \
                                            // expected-warning {{omitting the parameter name in a function definition is a C2x extension}}
 }
 
 // rdar://problem/8962770
 void test4(void) {
-  int (^f)(void) = ^((x)) { }; // expected-error {{type specifier missing}} expected-error {{type-id cannot have a name}}
+  int (^f)(void) = ^((x)) { }; // expected-warning {{type specifier missing}} expected-error {{type-id cannot have a name}}
 }
 
 // rdar://problem/9170609
 void test5_helper(void (^)(int, int[*]));
 void test5(void) {
   test5_helper(^(int n, int array[n]) {});
 }
 

clang/test/Sema/block-literal.c

takeblock(^{
         goto foo; // expected-error {{use of undeclared label 'foo'}}
         a: goto a;       // ok
       });
     break;
   }
 
   foo:
   takeblock(^{ x = 4; });  // expected-error {{variable is not assignable (missing __block type specifier)}}
-  __block y = 7;    // expected-error {{type specifier missing, defaults to 'int'}}
+  __block y = 7;    // expected-warning {{type specifier missing, defaults to 'int'}}
   takeblock(^{ y = 8; });
 }
 
 
 void (^test3(void))(void) {
   return ^{};
 }
 

clang/test/Sema/builtin-setjmp.c

 #elif ONLY_JMP_BUF
 typedef int *jmp_buf;
 #endif
 
 void use(void) {
   setjmp(0);
   #if NO_SETJMP
   // cxx-error@-2 {{undeclared identifier 'setjmp'}}
-  // c-error@-3 {{call to undeclared function 'setjmp'; ISO C99 and later do not support implicit function declarations}}
+  // c-warning@-3 {{call to undeclared function 'setjmp'; ISO C99 and later do not support implicit function declarations}}
   #elif ONLY_JMP_BUF
   // cxx-error@-5 {{undeclared identifier 'setjmp'}}
-  // c-error@-6 {{call to undeclared library function 'setjmp' with type 'int (jmp_buf)' (aka 'int (int *)'); ISO C99 and later do not support implicit function declarations}}
+  // c-warning@-6 {{call to undeclared library function 'setjmp' with type 'int (jmp_buf)' (aka 'int (int *)'); ISO C99 and later do not support implicit function declarations}}
   // c-note@-7 {{include the header <setjmp.h> or explicitly provide a declaration for 'setjmp'}}
   #else
   // cxx-no-diagnostics
   #endif
 
   #ifdef NO_SETJMP
   // In this case, the regular AST dump doesn't dump the implicit declaration of 'setjmp'.
   #pragma clang __debug dump setjmp

clang/test/Sema/builtins.c

void test18(void) {
   result = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst));
 
   ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src));      // expected-error {{too few arguments to function call}}
   ptr = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-error {{incompatible integer to pointer conversion}}
   ptr = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-error {{incompatible integer to pointer conversion}}
 }
 
 void no_ms_builtins(void) {
-  __assume(1); // expected-error {{call to undeclared function '__assume'; ISO C99 and later do not support implicit function declarations}}
-  __noop(1); // expected-error {{call to undeclared function '__noop'; ISO C99 and later do not support implicit function declarations}}
-  __debugbreak(); // expected-error {{call to undeclared function '__debugbreak'; ISO C99 and later do not support implicit function declarations}}
+  __assume(1); // expected-warning {{call to undeclared function '__assume'; ISO C99 and later do not support implicit function declarations}}
+  __noop(1); // expected-warning {{call to undeclared function '__noop'; ISO C99 and later do not support implicit function declarations}}
+  __debugbreak(); // expected-warning {{call to undeclared function '__debugbreak'; ISO C99 and later do not support implicit function declarations}}
 }
 
 void unavailable(void) {
   __builtin_operator_new(0); // expected-error {{'__builtin_operator_new' is only available in C++}}
   __builtin_operator_delete(0); // expected-error {{'__builtin_operator_delete' is only available in C++}}
 }
 
 // rdar://18259539

clang/test/Sema/crash-invalid-builtin.c

 // RUN: %clang_cc1 -triple=x86_64-apple-darwin -fsyntax-only -verify %s
 // PR23086
 
-__builtin_isinf(...); // expected-error {{type specifier missing, defaults to 'int'}} expected-error {{ISO C requires a named parameter before '...'}} // expected-error {{cannot redeclare builtin function '__builtin_isinf'}} // expected-note {{'__builtin_isinf' is a builtin with type 'int ()'}}
+__builtin_isinf(...); // expected-warning {{type specifier missing, defaults to 'int'}} expected-error {{ISO C requires a named parameter before '...'}} // expected-error {{cannot redeclare builtin function '__builtin_isinf'}} // expected-note {{'__builtin_isinf' is a builtin with type 'int ()'}}

clang/test/Sema/cxx-as-c.c

 // RUN: %clang_cc1 %s -verify
 
 // PR36157
 struct Foo {
-  Foo(int n) : n_(n) {} // expected-error 1+{{}}
+  Foo(int n) : n_(n) {} // expected-error 1+{{}} expected-warning 1+{{}}
 private:
   int n;
 };
 int main() { Foo f; } // expected-error 1+{{}}

clang/test/Sema/function.c

 void g(int (*compar)()) {
 }
 
 void h();  // expected-note {{previous declaration is here}}
 void h (const char *fmt, ...) {} // expected-error{{conflicting types for 'h'}}
 
 // PR1965
 int t5(b);          // expected-error {{parameter list without types}}
-int t6(int x, g);   // expected-error {{type specifier missing, defaults to 'int'}}
+int t6(int x, g);   // expected-warning {{type specifier missing, defaults to 'int'}}
 
 int t7(, );       // expected-error {{expected parameter declarator}} expected-error {{expected parameter declarator}}
 int t8(, int a);  // expected-error {{expected parameter declarator}}
 int t9(int a, );  // expected-error {{expected parameter declarator}}
 
 
 // PR2042
 void t10(){}
 void t11(){t10(1);} // expected-warning{{too many arguments}}
 
 // PR3208
 void t12(int) {}  // c2x-warning{{omitting the parameter name in a function definition is a C2x extension}}
 
 // PR2790
 void t13() {
   return 0; // expected-error {{void function 't13' should not return a value}}
 }
 int t14() {
   return; // expected-error {{non-void function 't14' should return a value}}
 }
 
 // <rdar://problem/6097326>
-y(y) { return y; } // expected-error{{parameter 'y' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}} \
-                   // expected-error{{type specifier missing, defaults to 'int'}}
+y(y) { return y; } // expected-warning{{parameter 'y' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                   // expected-warning{{type specifier missing, defaults to 'int'}}
 
 
 // PR3137, <rdar://problem/6127293>
 extern int g0_3137(void);
 void f0_3137() {
   int g0_3137(void);
 }
 void f1_3137() {

clang/test/Sema/implicit-builtin-decl.c

 // RUN: %clang_cc1 -fsyntax-only -Wno-strict-prototypes -verify %s
 
 void f() {
-  int *ptr = malloc(sizeof(int) * 10); // expected-error{{call to undeclared library function 'malloc' with type}} \
+  int *ptr = malloc(sizeof(int) * 10); // expected-warning{{call to undeclared library function 'malloc' with type}} \
   // expected-note{{include the header <stdlib.h> or explicitly provide a declaration for 'malloc'}} \
   // expected-note{{'malloc' is a builtin with type 'void *}}
 }
 
 void *alloca(__SIZE_TYPE__); // redeclaration okay
 
 int *calloc(__SIZE_TYPE__, __SIZE_TYPE__); // expected-warning{{incompatible redeclaration of library function 'calloc'}} \
                     // expected-note{{'calloc' is a builtin with type 'void *}}
 
 
 void g(int malloc) { // okay: these aren't functions
   int calloc = 1;
 }
 
 void h() {
   int malloc(int); // expected-warning{{incompatible redeclaration of library function 'malloc'}}
   int strcpy(int); // expected-warning{{incompatible redeclaration of library function 'strcpy'}} \
   // expected-note{{'strcpy' is a builtin with type 'char *(char *, const char *)'}}
 }
 
 void f2() {
   fprintf(0, "foo"); // expected-warning{{declaration of built-in function 'fprintf' requires inclusion of the header <stdio.h>}} \
-   expected-error {{call to undeclared function 'fprintf'; ISO C99 and later do not support implicit function declarations}}
+   expected-warning {{call to undeclared function 'fprintf'; ISO C99 and later do not support implicit function declarations}}
 }
 
 // PR2892
 void __builtin_object_size(); // expected-error{{conflicting types}} \
 // expected-note{{'__builtin_object_size' is a builtin with type}}
 
 int a[10];
 

clang/test/Sema/implicit-decl.c

-// RUN: %clang_cc1 %s -verify -fsyntax-only -Werror=implicit-function-declaration -std=c99
-// RUN: %clang_cc1 %s -verify -fsyntax-only -std=c11
+// RUN: %clang_cc1 %s -verify=werror,both -fsyntax-only -Werror=implicit-function-declaration -std=c99
+// RUN: %clang_cc1 %s -verify=expected,both -fsyntax-only -std=c11
 // RUN: %clang_cc1 %s -verify=c2x -fsyntax-only -std=c2x
 
 /// -Werror-implicit-function-declaration is a deprecated alias used by many projects.
-// RUN: %clang_cc1 %s -verify -fsyntax-only -Werror-implicit-function-declaration
+// RUN: %clang_cc1 %s -verify=werror,both -fsyntax-only -Werror-implicit-function-declaration
 
 // c2x-note@*:* {{'__builtin_va_list' declared here}}
 
 typedef int int32_t;
 typedef unsigned char Boolean;
 
-extern int printf(__const char *__restrict __format, ...); // expected-note{{'printf' declared here}} \
+extern int printf(__const char *__restrict __format, ...); // werror-note{{'printf' declared here}} \
                                                               c2x-note {{'printf' declared here}}
 
 void func(void) {
    int32_t *vector[16];
    const char compDesc[16 + 1];
    int32_t compCount = 0;
-   if (_CFCalendarDecomposeAbsoluteTimeV(compDesc, vector, compCount)) { // expected-error {{call to undeclared function '_CFCalendarDecomposeAbsoluteTimeV'; ISO C99 and later do not support implicit function declarations}} \
-                                                                            expected-note {{previous implicit declaration}} \
+   if (_CFCalendarDecomposeAbsoluteTimeV(compDesc, vector, compCount)) { // werror-error {{call to undeclared function '_CFCalendarDecomposeAbsoluteTimeV'; ISO C99 and later do not support implicit function declarations}} \
+                                                                            both-note {{previous implicit declaration}} \
+                                                                            expected-warning {{call to undeclared function '_CFCalendarDecomposeAbsoluteTimeV'; ISO C99 and later do not support implicit function declarations}} \
                                                                             c2x-error {{use of undeclared identifier '_CFCalendarDecomposeAbsoluteTimeV'}}
    }
 
-   printg("Hello, World!\n"); // expected-error{{call to undeclared function 'printg'; ISO C99 and later do not support implicit function declarations}} \
-                                 expected-note{{did you mean 'printf'?}} \
+   printg("Hello, World!\n"); // werror-error{{call to undeclared function 'printg'; ISO C99 and later do not support implicit function declarations}} \
+                                 werror-note{{did you mean 'printf'?}} \
+                                 expected-warning{{call to undeclared function 'printg'; ISO C99 and later do not support implicit function declarations}} \
                                  c2x-error {{use of undeclared identifier 'printg'; did you mean 'printf'?}}
 
-  __builtin_is_les(1, 3); // expected-error{{use of unknown builtin '__builtin_is_les'}} \
+  __builtin_is_les(1, 3); // both-error{{use of unknown builtin '__builtin_is_les'}} \
                              c2x-error {{unknown type name '__builtin_is_les'; did you mean '__builtin_va_list'?}} \
                              c2x-error {{expected identifier or '('}} \
                              c2x-error {{expected ')'}} \
                              c2x-note {{to match this '('}}
 }
-Boolean _CFCalendarDecomposeAbsoluteTimeV(const char *componentDesc, int32_t **vector, int32_t count) { // expected-error {{conflicting types}}
+Boolean _CFCalendarDecomposeAbsoluteTimeV(const char *componentDesc, int32_t **vector, int32_t count) { // both-error {{conflicting types}}
  return 0;
 }
 
 
 // Test the typo-correction callback in Sema::ImplicitlyDefineFunction
-extern int sformatf(char *str, __const char *__restrict __format, ...); // expected-note{{'sformatf' declared here}}
+extern int sformatf(char *str, __const char *__restrict __format, ...); // werror-note{{'sformatf' declared here}}
 void test_implicit(void) {
   int formats = 0; // c2x-note {{'formats' declared here}}
-  formatd("Hello, World!\n"); // expected-error{{call to undeclared function 'formatd'; ISO C99 and later do not support implicit function declarations}} \
-                                 expected-note{{did you mean 'sformatf'?}} \
+  formatd("Hello, World!\n"); // werror-error{{call to undeclared function 'formatd'; ISO C99 and later do not support implicit function declarations}} \
+                                 werror-note{{did you mean 'sformatf'?}} \
+                                 expected-warning{{call to undeclared function 'formatd'; ISO C99 and later do not support implicit function declarations}} \
                                  c2x-error {{use of undeclared identifier 'formatd'; did you mean 'formats'?}} \
                                  c2x-error {{called object type 'int' is not a function or function pointer}}
 }
 
 void test_suggestion(void) {
-  bark(); // expected-error {{call to undeclared function 'bark'; ISO C99 and later do not support implicit function declarations}} \
+  bark(); // werror-error {{call to undeclared function 'bark'; ISO C99 and later do not support implicit function declarations}} \
+             expected-warning {{call to undeclared function 'bark'; ISO C99 and later do not support implicit function declarations}} \
              c2x-error {{use of undeclared identifier 'bark'}}
-  bork(); // expected-error {{call to undeclared function 'bork'; ISO C99 and later do not support implicit function declarations}} \
+  bork(); // werror-error {{call to undeclared function 'bork'; ISO C99 and later do not support implicit function declarations}} \
+             expected-warning {{call to undeclared function 'bork'; ISO C99 and later do not support implicit function declarations}} \
              c2x-error {{use of undeclared identifier 'bork'}}
 }

clang/test/Sema/implicit-int.c

 /* RUN: %clang_cc1 -fsyntax-only -std=c89 -Wimplicit-int %s -verify -Wno-strict-prototypes
    RUN: %clang_cc1 -fsyntax-only -std=c99 %s -verify=ext -Wno-strict-prototypes
    RUN: %clang_cc1 -fsyntax-only -std=c2x %s -verify=unsupported
 */
 
 foo(void) { /* expected-warning {{type specifier missing, defaults to 'int'}} \
-               ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+               ext-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
                unsupported-error {{a type specifier is required for all declarations}} */
   return 0;
 }
 
 y;  /* expected-warning {{type specifier missing, defaults to 'int'}} \
-       ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+       ext-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
        unsupported-error {{a type specifier is required for all declarations}} */
 
 /* rdar://6131634 */
 void f((x));  /* expected-warning {{type specifier missing, defaults to 'int'}} \
-                 ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                 ext-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
                  unsupported-error {{a type specifier is required for all declarations}} */
 
 /* PR3702 */
 #define PAD(ms10) { \
     register i;     \
 }
 
 #define ILPAD() PAD((NROW - tt.tt_row) * 10) /* 1 ms per char */
 
 void
-h19_insline(n)  /* ext-error {{parameter 'n' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+h19_insline(n)  /* ext-warning {{parameter 'n' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}} \
                    unsupported-error {{unknown type name 'n'}} */
 {
   ILPAD();  /* expected-warning {{type specifier missing, defaults to 'int'}} \
-               ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+               ext-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
                unsupported-error {{a type specifier is required for all declarations}} */
 
 }
 
 struct foo {
  __extension__ __attribute__((packed)) x : 4; /* expected-warning {{type specifier missing, defaults to 'int'}} \
-                                                 ext-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
+                                                 ext-warning {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} \
                                                  unsupported-error {{unknown type name 'x'}} */
 
 };

clang/test/Sema/implicit-intel-builtin-decl.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-feature +sse2 -fsyntax-only -verify=expected,c %s
 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -target-feature +sse2 -fsyntax-only -verify=expected,cxx %s -x c++
 
 void f(void) {
   (void)_mm_getcsr(); // cxx-warning{{implicitly declaring library function '_mm_getcsr'}} \
-                         c-error{{call to undeclared library function '_mm_getcsr'}} \
+                         c-warning{{call to undeclared library function '_mm_getcsr'}} \
                          expected-note{{include the header <xmmintrin.h> or explicitly provide a declaration for '_mm_getcsr'}}
   _mm_setcsr(1); // cxx-warning{{implicitly declaring library function '_mm_setcsr'}} \
-                    c-error{{call to undeclared library function '_mm_setcsr'}} \
+                    c-warning{{call to undeclared library function '_mm_setcsr'}} \
                     expected-note{{include the header <xmmintrin.h> or explicitly provide a declaration for '_mm_setcsr'}}
   _mm_sfence(); // cxx-warning{{implicitly declaring library function '_mm_sfence'}} \
-                   c-error{{call to undeclared library function '_mm_sfence'}} \
+                   c-warning{{call to undeclared library function '_mm_sfence'}} \
                    expected-note{{include the header <xmmintrin.h> or explicitly provide a declaration for '_mm_sfence'}}
 
   _mm_clflush((void*)0); // cxx-warning{{implicitly declaring library function '_mm_clflush'}} \
-                            c-error{{call to undeclared library function '_mm_clflush'}} \
+                            c-warning{{call to undeclared library function '_mm_clflush'}} \
                             expected-note{{include the header <emmintrin.h> or explicitly provide a declaration for '_mm_clflush'}}
   _mm_lfence(); // cxx-warning{{implicitly declaring library function '_mm_lfence'}} \
-                   c-error{{call to undeclared library function '_mm_lfence'}} \
+                   c-warning{{call to undeclared library function '_mm_lfence'}} \
                    expected-note{{include the header <emmintrin.h> or explicitly provide a declaration for '_mm_lfence'}}
   _mm_mfence(); // cxx-warning{{implicitly declaring library function '_mm_mfence'}} \
-                   c-error{{call to undeclared library function '_mm_mfence'}} \
+                   c-warning{{call to undeclared library function '_mm_mfence'}} \
                    expected-note{{include the header <emmintrin.h> or explicitly provide a declaration for '_mm_mfence'}}
   _mm_pause(); // cxx-warning{{implicitly declaring library function '_mm_pause'}} \
-                  c-error{{call to undeclared library function '_mm_pause'}} \
+                  c-warning{{call to undeclared library function '_mm_pause'}} \
                   expected-note{{include the header <emmintrin.h> or explicitly provide a declaration for '_mm_pause'}}
 }
 
 unsigned int _mm_getcsr(void);
 void _mm_setcsr(unsigned int);
 void _mm_sfence(void);
 
 void _mm_clflush(void const *);

clang/test/Sema/implicit-ms-builtin-decl.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsyntax-only -verify %s -fms-extensions
 // RUN: %clang_cc1 -triple i386-unknown-unknown -fsyntax-only -verify %s -fms-extensions
 
 void f(void) {
-  (void)_byteswap_ushort(42); // expected-error{{call to undeclared library function '_byteswap_ushort'}} \
+  (void)_byteswap_ushort(42); // expected-warning{{call to undeclared library function '_byteswap_ushort'}} \
   // expected-note{{include the header <stdlib.h> or explicitly provide a declaration for '_byteswap_ushort'}}
-  (void)_byteswap_uint64(42LL); // expected-error{{call to undeclared library function '_byteswap_uint64'}} \
+  (void)_byteswap_uint64(42LL); // expected-warning{{call to undeclared library function '_byteswap_uint64'}} \
   // expected-note{{include the header <stdlib.h> or explicitly provide a declaration for '_byteswap_uint64'}}
 }
 
 void _byteswap_ulong(void); // expected-warning{{incompatible redeclaration of library function '_byteswap_ulong'}} \
 // expected-note{{'_byteswap_ulong' is a builtin}}
 
 unsigned short _byteswap_ushort(unsigned short);
 unsigned long long _byteswap_uint64(unsigned long long);
 
 void g(void) {
   (void)_byteswap_ushort(42);
   (void)_byteswap_uint64(42LL);
 }
 
 #if defined(__x86_64__)
 void h(void) {
-  (void)__mulh(21, 2);  // expected-error{{call to undeclared library function '__mulh'}} \
+  (void)__mulh(21, 2);  // expected-warning{{call to undeclared library function '__mulh'}} \
   // expected-note{{include the header <intrin.h> or explicitly provide a declaration for '__mulh'}}
-  (void)__umulh(21, 2); // expected-error{{call to undeclared library function '__umulh'}} \
+  (void)__umulh(21, 2); // expected-warning{{call to undeclared library function '__umulh'}} \
   // expected-note{{include the header <intrin.h> or explicitly provide a declaration for '__umulh'}}
 }
 
 long long __mulh(long long, long long);
 unsigned long long __umulh(unsigned long long, unsigned long long);
 
 void i(void) {
   (void)__mulh(21, 2);
   (void)__umulh(21, 2);
 }
 #endif
 
 #if defined(i386)
 void h(void) {
-  (void)__mulh(21LL, 2LL);  // expected-error{{call to undeclared function '__mulh'; ISO C99 and later do not support implicit function declarations}}
-  (void)__umulh(21ULL, 2ULL);  // expected-error{{call to undeclared function '__umulh'; ISO C99 and later do not support implicit function declarations}}
+  (void)__mulh(21LL, 2LL);  // expected-warning{{call to undeclared function '__mulh'; ISO C99 and later do not support implicit function declarations}}
+  (void)__umulh(21ULL, 2ULL);  // expected-warning{{call to undeclared function '__umulh'; ISO C99 and later do not support implicit function declarations}}
 }
 #endif

clang/test/Sema/invalid-decl.c

 // RUN: %clang_cc1 %s -fsyntax-only -Wno-strict-prototypes -verify
 
 void test(void) {
     char = 4;  // expected-error {{expected identifier}}
 }
 
 
 // PR2400
-typedef xtype (*x)(void* handle); // expected-error {{function cannot return function type}} expected-error 2{{type specifier missing, defaults to 'int'}}
+typedef xtype (*x)(void* handle); // expected-error {{function cannot return function type}} expected-warning 2{{type specifier missing, defaults to 'int'}}
 
 typedef void ytype();
 
 
 typedef struct _zend_module_entry zend_module_entry;
 struct _zend_module_entry {
     ytype globals_size; // expected-error {{field 'globals_size' declared as a function}}
 };

clang/test/Sema/invalid-struct-init.c

 // RUN: %clang_cc1 %s -verify -fsyntax-only
 
 typedef struct _zend_module_entry zend_module_entry;
 struct _zend_module_entry {
   _efree((p)); // expected-error{{type name requires a specifier or qualifier}} \
-                  expected-error {{type specifier missing, defaults to 'int'}}
+                  expected-warning {{type specifier missing, defaults to 'int'}}
 
 };
 typedef struct _zend_function_entry { } zend_function_entry;
 typedef struct _zend_pcre_globals { } zend_pcre_globals;
 zend_pcre_globals pcre_globals;
 
 static void zm_globals_ctor_pcre(zend_pcre_globals *pcre_globals ) { }
 static void zm_globals_dtor_pcre(zend_pcre_globals *pcre_globals ) { }

clang/test/Sema/redefinition.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify -Wno-strict-prototypes
 int f(int a) { return 0; } // expected-note {{previous definition is here}}
 int f(int);
 int f(int a) { return 0; } // expected-error {{redefinition of 'f'}}
 
 // <rdar://problem/6097326>
-int foo(x) { // expected-error {{parameter 'x' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
+int foo(x) { // expected-warning {{parameter 'x' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
   return 0;
 }
 int x = 1;
 
 // <rdar://problem/6880464>
 extern inline int g(void) { return 0; } // expected-note{{previous definition}}
 int g(void) { return 0; } // expected-error{{redefinition of a 'extern inline' function 'g' is not supported in C99 mode}}

clang/test/Sema/typo-correction.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 //
 // This file contains typo correction tests which hit different code paths in C
 // than in C++ and may exhibit different behavior as a result.
 
 __typeof__(struct F*) var[invalid];  // expected-error-re {{use of undeclared identifier 'invalid'{{$}}}}
 
 void PR21656(void) {
   float x;
   x = (float)arst;  // expected-error-re {{use of undeclared identifier 'arst'{{$}}}}
 }
 
-a = b ? : 0;  // expected-error {{type specifier missing, defaults to 'int'}} \
+a = b ? : 0;  // expected-warning {{type specifier missing, defaults to 'int'}} \
               // expected-error {{use of undeclared identifier 'b'}}
 
 int foobar;  // expected-note {{'foobar' declared here}}
-new_a = goobar ?: 4; // expected-error {{type specifier missing, defaults to 'int'}} \
+new_a = goobar ?: 4; // expected-warning {{type specifier missing, defaults to 'int'}} \
                       // expected-error {{use of undeclared identifier 'goobar'; did you mean 'foobar'?}} \
                       // expected-error {{initializer element is not a compile-time constant}}
 
 struct ContainerStuct {
   enum { SOME_ENUM }; // expected-note {{'SOME_ENUM' declared here}}
 };
 
 void func(int arg) {
   switch (arg) {
   case SOME_ENUM_: // expected-error {{use of undeclared identifier 'SOME_ENUM_'; did you mean 'SOME_ENUM'}}
     ;
   }
 }
 
 void banana(void);  // expected-note {{'banana' declared here}}
 int c11Generic(int arg) {
   _Generic(hello, int : banana)();  // expected-error-re {{use of undeclared identifier 'hello'{{$}}}}
   _Generic(arg, int : bandana)();  // expected-error {{use of undeclared identifier 'bandana'; did you mean 'banana'?}}
 }
 
 typedef long long __m128i __attribute__((__vector_size__(16)));
 int PR23101(__m128i __x) {
-  return foo((__v2di)__x);  // expected-error {{call to undeclared function 'foo'; ISO C99 and later do not support implicit function declarations}} \
+  return foo((__v2di)__x);  // expected-warning {{call to undeclared function 'foo'; ISO C99 and later do not support implicit function declarations}} \
                             // expected-error {{use of undeclared identifier '__v2di'}}
 }
 
 void f(long *a, long b) {
       __atomic_or_fetch(a, b, c);  // expected-error {{use of undeclared identifier 'c'}}
 }
 
 extern double cabs(_Complex double z);

clang/test/Sema/varargs.c

#ifndef MS
   // argument promotions.
   // expected-note@-7 {{parameter of type 'enum E1' is declared here}}
   // expected-warning@-6 {{passing an object that undergoes default argument promotion to 'va_start' has undefined behavior}}
 #endif
   __builtin_va_end(va);
 }
 
 void f14(int e, ...) {
-  // expected-error@+3 {{call to undeclared library function 'va_start'}}
+  // expected-warning@+3 {{call to undeclared library function 'va_start'}}
   // expected-note@+2 {{include the header <stdarg.h>}}
   // expected-error@+1 {{too few arguments to function call}}
   va_start();
   __builtin_va_list va;
   va_start(va, e);
 }

clang/test/Sema/vla.c

 // Make sure this isn't treated as an error
 int TransformBug(int a) {
  return sizeof(*(int(*)[({ goto v; v: a;})]) 0); // expected-warning {{use of GNU statement expression extension}}
 }
 
 // PR36157
 struct {
   int a[ // expected-error {{variable length array in struct}}
-    implicitly_declared() // expected-error {{call to undeclared function 'implicitly_declared'; ISO C99 and later do not support implicit function declarations}}
+    implicitly_declared() // expected-warning {{call to undeclared function 'implicitly_declared'; ISO C99 and later do not support implicit function declarations}}
   ];
 };
 int (*use_implicitly_declared)(void) = implicitly_declared; // ok, was implicitly declared at file scope
 
 void VLAPtrAssign(int size) {
   int array[1][2][3][size][4][5];
   // This is well formed
   int (*p)[2][3][size][4][5] = array;

clang/test/SemaObjC/builtin_objc_lib_functions.m

 // RUN: %clang_cc1 -x objective-c %s -fsyntax-only -verify
 // rdar://8592641
-Class f0(void) { return objc_getClass("a"); } // expected-error {{call to undeclared library function 'objc_getClass' with type 'id (const char *)'}} \
+Class f0(void) { return objc_getClass("a"); } // expected-warning {{call to undeclared library function 'objc_getClass' with type 'id (const char *)'}} \
             // expected-note {{include the header <objc/runtime.h> or explicitly provide a declaration for 'objc_getClass'}}
 
 // rdar://8735023
-Class f1(void) { return objc_getMetaClass("a"); } // expected-error {{call to undeclared library function 'objc_getMetaClass' with type 'id (const char *)'}} \
+Class f1(void) { return objc_getMetaClass("a"); } // expected-warning {{call to undeclared library function 'objc_getMetaClass' with type 'id (const char *)'}} \
             // expected-note {{include the header <objc/runtime.h> or explicitly provide a declaration for 'objc_getMetaClass'}}
 
-void f2(id val) { objc_enumerationMutation(val); } // expected-error {{call to undeclared library function 'objc_enumerationMutation' with type 'void (id)'}} \
+void f2(id val) { objc_enumerationMutation(val); } // expected-warning {{call to undeclared library function 'objc_enumerationMutation' with type 'void (id)'}} \
                // expected-note {{include the header <objc/runtime.h> or explicitly provide a declaration for 'objc_enumerationMutation'}}
 
-long double f3(id self, SEL op) { return objc_msgSend_fpret(self, op); } // expected-error {{call to undeclared library function 'objc_msgSend_fpret' with type 'long double (id, SEL, ...)'}} \
+long double f3(id self, SEL op) { return objc_msgSend_fpret(self, op); } // expected-warning {{call to undeclared library function 'objc_msgSend_fpret' with type 'long double (id, SEL, ...)'}} \
     // expected-note {{include the header <objc/message.h> or explicitly provide a declaration for 'objc_msgSend_fpret'}}
 
 id f4(struct objc_super *super, SEL op) { // expected-warning {{declaration of 'struct objc_super' will not be visible outside of this function}}
-  return objc_msgSendSuper(super, op); // expected-error {{call to undeclared library function 'objc_msgSendSuper' with type 'id (struct objc_super *, SEL, ...)'}} \
+  return objc_msgSendSuper(super, op); // expected-warning {{call to undeclared library function 'objc_msgSendSuper' with type 'id (struct objc_super *, SEL, ...)'}} \
           // expected-note {{include the header <objc/message.h> or explicitly provide a declaration for 'objc_msgSendSuper'}}
 }
 
 id f5(id val, id *dest) {
-  return objc_assign_strongCast(val, dest); // expected-error {{call to undeclared library function 'objc_assign_strongCast' with type 'id (id, id *)'}} \
+  return objc_assign_strongCast(val, dest); // expected-warning {{call to undeclared library function 'objc_assign_strongCast' with type 'id (id, id *)'}} \
               // expected-note {{include the header <objc/objc-auto.h> or explicitly provide a declaration for 'objc_assign_strongCast'}}
 }
 
 int f6(Class exceptionClass, id exception) {
-  return objc_exception_match(exceptionClass, exception); // expected-error {{call to undeclared library function 'objc_exception_match' with type 'int (id, id)'}} \
+  return objc_exception_match(exceptionClass, exception); // expected-warning {{call to undeclared library function 'objc_exception_match' with type 'int (id, id)'}} \
                   // expected-note {{include the header <objc/objc-exception.h> or explicitly provide a declaration for 'objc_exception_match'}}
 }

clang/test/SemaObjC/builtin_objc_nslog.m

 // RUN: %clang_cc1 -x objective-c %s -fsyntax-only -verify
 
 #include <stdarg.h>
 
 void f1(id arg) {
-  NSLog(@"%@", arg); // expected-error {{call to undeclared library function 'NSLog' with type 'void (id, ...)'}} \
+  NSLog(@"%@", arg); // expected-warning {{call to undeclared library function 'NSLog' with type 'void (id, ...)'}} \
   // expected-note {{include the header <Foundation/NSObjCRuntime.h> or explicitly provide a declaration for 'NSLog'}}
 }
 
 void f2(id str, va_list args) {
-  NSLogv(@"%@", args); // expected-error {{call to undeclared library function 'NSLogv' with type }} \
+  NSLogv(@"%@", args); // expected-warning {{call to undeclared library function 'NSLogv' with type }} \
   // expected-note {{include the header <Foundation/NSObjCRuntime.h> or explicitly provide a declaration for 'NSLogv'}}
 }

clang/test/SemaObjC/ivar-lookup-resolution-builtin.m

 }
 - (int) InstMethod;
 + (int) ClassMethod;
 @end
 
 @implementation Test1
 - (int) InstMethod
 {
-  return index; // expected-error {{call to undeclared library function 'index'}} \
+  return index; // expected-warning {{call to undeclared library function 'index'}} \
                 // expected-note {{include the header <strings.h> or explicitly provide a declaration for 'index'}} \
                 // expected-error {{incompatible pointer to integer conversion returning}}
 }
 + (int) ClassMethod
 {
   return index; // expected-error {{incompatible pointer to integer conversion returning}}
 }
 @end
 

clang/test/SemaObjC/protocols.m

 @protocol C < B > // expected-note{{previous definition is here}}
 @end
 @protocol A < C > 
 @end
 @protocol B < A > // expected-error{{protocol has circular dependency}}
 @end
 
 @protocol P
-- (int)test:(int)param, ..; // expected-error{{type specifier missing}} \
+- (int)test:(int)param, ..; // expected-warning{{type specifier missing}} \
                       // expected-error{{expected ';' after method prototype}}
 @end

clang/test/SemaOpenCL/invalid-pipes-cl1.2.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2
 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=-all
 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=clc++2021 -cl-ext=-all
 
 void foo(read_only pipe int p);
 #if __OPENCL_C_VERSION__ > 120
 // expected-error@-2 {{OpenCL C version 3.0 does not support the 'pipe' type qualifier}}
 // expected-error@-3 {{access qualifier can only be used for pipe and image type}}
 #elif defined(__OPENCL_CPP_VERSION__)
 // expected-error@-5 {{C++ for OpenCL version 2021 does not support the 'pipe' type qualifier}}
 // expected-error@-6 {{access qualifier can only be used for pipe and image type}}
 #else
-// expected-error@-8 {{type specifier missing, defaults to 'int'}}
+// expected-warning@-8 {{type specifier missing, defaults to 'int'}}
 // expected-error@-9 {{access qualifier can only be used for pipe and image type}}
 // expected-error@-10 {{expected ')'}} expected-note@-10 {{to match this '('}}
 #endif
 
 // 'pipe' should be accepted as an identifier.
 typedef int pipe;
 #if __OPENCL_C_VERSION__ > 120
 // expected-error@-2 {{OpenCL C version 3.0 does not support the 'pipe' type qualifier}}