[C89/C2x] Improve diagnostics around strict prototypes in C

[aaron.ballman]

Summary

Functions without prototypes in C (also known as K&R C functions) were introduced into C89 as a deprecated feature and C2x is now reclaiming that syntax space with different semantics. However, Clang's -Wstrict-prototypes diagnostic is off-by-default (even in pedantic mode) and does not suffice to warn users about issues in their code.

This patch changes the behavior of -Wstrict-prototypes to only diagnose declarations and definitions which are not going to change behavior in C2x mode, and enables the diagnostic in -pedantic mode. The diagnostic is now specifically about the fact that the feature is deprecated.

It also adds -Wdeprecated-non-prototype, which is grouped under -Wstrict-prototypes and diagnoses declarations or definitions which will change behavior in C2x mode. This diagnostic is enabled by default because the risk is higher for the user to continue to use the deprecated feature.

A few things to note:

• The RFC for this can be found at: https://discourse.llvm.org/t/rfc-enabling-wstrict-prototypes-by-default-in-c
• There is some awkward overlap between the diagnostics, but the best time to diagnose a function type without a prototype is when forming the function type, but we don't know whether the behavior will change in C2x at that point. So we alter the behavior sometimes depending on whether -Wstrict-prototypes is enabled in an effort to keep the diagnostics understandable and not too chatty.
• There will be another patch for handling call site behavior as a follow-up.

[aaron.ballman]

Rebased, no changes.

[cor3ntin]

clang/include/clang/Basic/DiagnosticSemaKinds.td

5566–5567

"declaration of a function without a prototype is deprecated", may be slightly better?

clang/lib/Sema/SemaDecl.cpp

3881

I wonder if

• This shouldn't be placed in a separate function for clarity
• We could bail out early for built ins ?

clang/lib/Sema/SemaType.cpp

5560–5562

if (!LangOpts.CPlusPlus) is probably enough here

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

5566–5567

Sure, I can reword the rest so they're consistent.

clang/lib/Sema/SemaDecl.cpp

3881

The change looks more complicated than it is because of the indentation changes -- I'm not certain putting this in its own function gains a whole lot (it's not reusable below; I already looked into doing that and wasn't happy with the results).

We can't bail out early for builtins because we still issue diagnostics in cases where only one side is a builtin. e.g.,

void exit(); // We still want to diagnose this as changing behavior specifically

See test/Sema/knr-variadic-def.c for this test case.

clang/lib/Sema/SemaType.cpp

5560–5562

Hmm, yeah, you're right. Good catch!

[jyknight]

Starting by looking at the test cases, I've got some suggestions on making the diagnostics a bit less confusing.

clang/test/CodeGen/2009-06-01-addrofknr.c

8

This message seems vaguer than necessary, since we know _for sure_ this is invalid.

Can we say something like: "K&R-style function definitions are deprecated in all versions of C and not supported in C2x"?

clang/test/Parser/declarators.c

5

Perhaps we should add an explanation to the message like
(specify '(void)' if you intended to accept no arguments)
to make it clearer to folks who aren't familiar with this weirdness yet?

clang/test/Sema/implicit-decl.c

25

It's not "preceded by a function without a prototype", though, it's preceeded by a implicit declaration due to a call. Which we would've already diagnosed with the default-on -Wimplicit-function-declaration diagnostic.

Although...what _is_ the desired behavior of an implicit function declaration in C2x mode? If we permit it _at all_, it must still create a non-prototype function declaration, I expect. In that case this decl with types would still be valid, so the warning is just wrong.

clang/test/Sema/knr-def-call.c

15

I think we don't want to emit a warning here. If a declaration with params doesn't match a K&R definition, we already emit a conflicting-types error.

[[Well...except for one case, I've noticed -- we don't current emit any warning when a definition with no parameters fails to match a preceding declaration with params, e.g. void f(int); void f() { }. I'm quite surprised -- I'm willing to say that such code is 100% just a bug, not intentional. I note that GCC unconditionally rejects it. I think we should also be emitting an unconditional error in that case.]]]

Anyhow, when you have a K&R style definition with parameters, that -- all by itself -- is definitely invalid in C2x, so we don't need to emit any warning on the declaration.

clang/test/Sema/warn-deprecated-non-prototype.c

46

Maybe something like "this function declaration will conflict with the preceding declaration in C2x, because the preceding declaration does not specify arguments."

[aaron.ballman]

clang/test/CodeGen/2009-06-01-addrofknr.c

8

I'd like to avoid using K&R in the diagnostic text (we're inconsistent about K&R vs prototype, etc already, but I'd like to see us excise K&R from diagnostics because it's not particularly descriptive to anyone younger than about 40. :-D

How about: function declarations without a prototype are deprecated in all versions of C and not supported in C2x ?

clang/test/Parser/declarators.c

5

They're already offered a fixit for this situation, so I don't know that we need the extra explanation? The user currently gets something like this:

C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:2:16: warning: declaration of a function without a prototype is deprecated in all versions of C [-Wstrict-prototypes]
void other_func();
               ^
                void

Do you still think the diagnostic needs to be made longer?

clang/test/Sema/implicit-decl.c

25

It's not "preceded by a function without a prototype", though, it's preceeded by a implicit declaration due to a call. Which we would've already diagnosed with the default-on -Wimplicit-function-declaration diagnostic.

In order for that to work, Clang gins up an implicit declaration of extern int func(); which is the signature C89 requires, so I think the diagnostic here is fine (it's also a very weird edge case I don't expect people to hit all that often, since the only way to trigger this diagnostic is to define with a prototype the implicitly-declared function).

There are no implicit function declarations after C89 (warned by default, but should be an error). There's also no implicit int after C89 (not even warned on by default, but should also be an error). Personally, I would like to see us enable both diagnostics as warning-defaults-to-error in C99 through C17 (if possible) and error only in C2x and forward, but I've not proposed it or worked on it yet (fixing one horror show at a time, basically).

clang/test/Sema/knr-def-call.c

15

I'm quite surprised -- I'm willing to say that such code is 100% just a bug, not intentional. I note that GCC unconditionally rejects it. I think we should also be emitting an unconditional error in that case.

I'd rather we be consistent here -- either every mixture of prototype/unprototyped is an error, or they're all a warning. I've added your example as a test case and we warn on it as being a change of behavior in C2x, which I think is defensible.

Anyhow, when you have a K&R style definition with parameters, that -- all by itself -- is definitely invalid in C2x, so we don't need to emit any warning on the declaration.

I tend to agree, let me see what I can do.

clang/test/Sema/warn-deprecated-non-prototype.c

46

I can see the appeal, but that makes the diagnostic rather long and I'd still like to be consistent in the terminology we use. Given that the old diagnostic was -Wstrict-prototypes and the new one is -Wdeprecated-non-prototype, I think we don't need to tie ourselves into knots to avoid using the terminology. Do you feel strongly about rewording this?

[aaron.ballman]

Updating based on review feedback.

clang/test/CodeGen/2009-06-01-addrofknr.c

8

I went with a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x, let me know if you think it needs further adjusting. I also reworded the other diagnostics to sound similar.

clang/test/Parser/declarators.c

5

I elected to leave this alone unless you feel strongly.

clang/test/Sema/knr-def-call.c

15

I addressed this so we no longer diagnose the function with a prototype in the case where it precedes the function without a prototype.

clang/test/Sema/warn-deprecated-non-prototype.c

46

I've elected to leave this one alone unless you feel strongly.

[aaron.ballman]

Fix failing test case caught by precommit CI.

[aaron.ballman]

Ping

[aaron.ballman]

Thanks @erichkeane!

@jyknight, @hubert.reinterpretcast, @eli.friedman -- I'll likely land this sometime tomorrow unless I hear from you. But if I land it and you still have comments, I'll be happy to address them post commit.

[jyknight]

clang/test/CodeGen/2009-06-01-addrofknr.c

8

I do agree with you that "K&R" is perhaps not the best name either...

But I think this warning message may still be confusing to users. A typical C user I think will be surprised to see a warning about a "declaration" pointing to a definition -- even though that is technically accurate. Especially when we're complaining concretely about the weird old definition syntax, it would be better to say "definition".

It looks like the most common name for this is "old-style function definition" -- both GCC and MSVC use that name, and clang also did, before. (Hmmm. And GCC actually seems to place this particular warning under the off-by-default -Wold-style-definition flag -- which clang doesn't implement.) I don't know that "old-style" is a great description either, but "old-style function definition" definitely seems more understandable than "function declaration without a prototype" when talking about a K&R-style separated-arguments-types definition.

clang/test/Parser/declarators.c

5

I guess I sort of wondered if users might consider "without a prototype" to generally indicate "implicit declaration". So, the wording "declaration without a prototype" might be like..."wait you're complaining that my declaration doesn't have a declaration? Huh? It's right there!"

But, with the fixit hint suggesting the addition of "void", that's probably sufficiently explanatory.

clang/test/Sema/knr-def-call.c

15

I'd rather we be consistent here -- either every mixture of prototype/unprototyped is an error, or they're all a warning. I've added your example as a test case and we warn on it as being a change of behavior in C2x, which I think is defensible.

Even before, we are NOT consistent. We emit an error on void f(int); void f(x) float x; {}, but not for void f(int); void f() {}. In both cases, we have a prototyped declaration, followed by an old-style "prototypeless" definition. I think it would be sensible to diagnose with an unconditional error in both cases, not only the former.

[aaron.ballman]

clang/test/CodeGen/2009-06-01-addrofknr.c

8

But I think this warning message may still be confusing to users. A typical C user I think will be surprised to see a warning about a "declaration" pointing to a definition -- even though that is technically accurate. Especially when we're complaining concretely about the weird old definition syntax, it would be better to say "definition".

I can look into making it say "definition" when written on a definition, but this feels like it's starting to split awfully fine hairs to me, so if it turns out to add more code than I think it's worth, I may stick with "declaration" because it's still correct and I don't think the confusion should impede a user's ability to fix the bug *too much*.

clang/test/Parser/declarators.c

5

I guess I sort of wondered if users might consider "without a prototype" to generally indicate "implicit declaration". So, the wording "declaration without a prototype" might be like..."wait you're complaining that my declaration doesn't have a declaration? Huh? It's right there!"

That's a good point, we should watch to see if that sort of confusion does happen in practice (I'll keep my eyes peeled), but I also think the fix-it should be sufficiently clarifying for most folks.

clang/test/Sema/knr-def-call.c

15

Even before, we are NOT consistent. We emit an error on void f(int); void f(x) float x; {}, but not for void f(int); void f() {}. In both cases, we have a prototyped declaration, followed by an old-style "prototypeless" definition. I think it would be sensible to diagnose with an unconditional error in both cases, not only the former.

I don't think void f(int); void f() {} should be diagnosed solely as an issue with strict prototypes; I think it should be diagnosed the same as void f(int); void f(x) float x; {}, which is *not* about strict prototypes but *is* about the fact that the function types cannot merge because they conflict. Once there's a declaration with a prototype, the function always has a prototype (see C17 6.2.7p3 ) and redeclarations (including for definition) need to have a compatible signature (see C17 6.7.6.3p15). So I'd expect a conflicting types error diagnostic. I think it's defensible to *additionally* issue the strict prototypes warning (though if we can silence the warning because we're already issuing an error without introducing significant extra complexity, that would be ideal). I'll look into adding the error diagnostic.

[jyknight]

clang/test/Sema/knr-def-call.c

15

Sorry about being unclear -- what you propose is precisely what I meant to say.

[aaron.ballman]

clang/test/Sema/knr-def-call.c

15

Thank you for confirming (and poking me about this). As always, I really appreciate your input!

[aaron.ballman]

clang/test/CodeGen/2009-06-01-addrofknr.c

8

Yup, this turned out to be hard enough to not be worth it IMO. The issue is that when merging function declarations, we don't know whether the function we want to diagnose is a definition or not (we've not yet started parsing its body, we've just finished with its declarator).

[manojgupta]

Some of our users are not very happy with the churn probably caused by this change where the declaration has the "void" argument but the later definition does not have explicit "void".

void foo(void);

void foo() 
{
}

GCC does not warn about this usage: https://godbolt.org/z/zPP8qjc98

Any opinions?

[aaron.ballman]

In D122895#3481564, @manojgupta wrote:

Some of our users are not very happy with the churn probably caused by this change where the declaration has the "void" argument but the later definition does not have explicit "void".

void foo(void);

void foo() 
{
}

GCC does not warn about this usage: https://godbolt.org/z/zPP8qjc98

Any opinions?

Thank you for the feedback! I think it's debatable whether this is a bug or not, but it's an interesting case that I may think about a bit further before making any final decisions. My current thinking is...

We turned -Wstrict-prototypes into a pedantic warning specifically telling the user about K&R C function usage everywhere it occurs, and from that perspective void f() {} is correct to diagnose pedantically as the signature is specifically a K&R C one. However, the composite type between void f(void) (with a parameter list) and void f() {} (with an empty identifier list) is a function with a prototype of void(void) (per C99 6.2.7p3). Thus, a call to the function through the declaration can pass no arguments, and a call to the function through the definition can pass no arguments, and so it also seems reasonable to not diagnose.

(We added -Wdeprecated-non-prototype to cover the case where there's a behavioral change to the code in C2x, which diagnoses void f(int); and void f(i) int i; {} (this code will break in C2x), so despite the similarity with your case, it's a different diagnostic entirely.)

FWIW, GCC's behavior isn't particularly interesting because we're knowingly diverging from their strategy with the warning, so it's not too surprising that our behavior is different.

I think what sells it for me not being a bug is that we issue that warning when determining the function *type* when forming the declaration which happens before doing function merging. At the point where we issue this warning, we don't have enough information to know whether the function will eventually have a composite type with a prototype or not (we don't even have enough information to know whether it's for a function declaration or not; it could be for a typedef, etc), so suppressing the diagnostic would be rather difficult. And because it's a pedantic warning specifically, I think it's defensible that we're issuing the diagnostic.

Is disabling the pedantic warning an option for your users?

[tahonermann]

I think it's debatable whether this is a bug or not

For C99 through C17, I kind of agree, but for C2x (where the warning is still issued with -Wstrict-prototypes), my understanding is that void foo(void) and void foo() are equivalent; there is no unprototyped declaration. I think the diagnostic should at least be suppressed for C2x since we don't want to encourage programmers to explicitly add void when targeting that standard.

[aaron.ballman]

In D122895#3482555, @tahonermann wrote:

I think it's debatable whether this is a bug or not

For C99 through C17, I kind of agree, but for C2x (where the warning is still issued with -Wstrict-prototypes), my understanding is that void foo(void) and void foo() are equivalent; there is no unprototyped declaration. I think the diagnostic should at least be suppressed for C2x since we don't want to encourage programmers to explicitly add void when targeting that standard.

Good catch... -Wstrict-prototypes should be a noop in C2x mode! I'll work on fixing that.

[manojgupta]

Is disabling the pedantic warning an option for your users?

Disabling it wholesale is not an option since they actually want this warning (the older version). But we agreed to disable it specifically for the code where the warning was getting fired.
One instance is https://review.coreboot.org/c/coreboot/+/63936 .

I have been fixing our codebase to clean this and clean the instances. But it takes a lot of time and effort. Plus it takes a long time to clean one failure before I can find others (public CLs) https://chromium-review.googlesource.com/q/Wstrict-prototypes+owner:manojgupta

[aaron.ballman]

In D122895#3482707, @manojgupta wrote:

Is disabling the pedantic warning an option for your users?

Disabling it wholesale is not an option since they actually want this warning (the older version). But we agreed to disable it specifically for the code where the warning was getting fired.
One instance is https://review.coreboot.org/c/coreboot/+/63936 .

I have been fixing our codebase to clean this and clean the instances. But it takes a lot of time and effort. Plus it takes a long time to clean one failure before I can find others (public CLs) https://chromium-review.googlesource.com/q/Wstrict-prototypes+owner:manojgupta

Out of curiosity, are you using K&R C functions in your code base (definitions with an identifier list or a declaration with empty parens)? Basically, I'm wondering if you'd be able to enable -fno-knr-function?

[aaron.ballman]

In D122895#3482575, @aaron.ballman wrote:

In D122895#3482555, @tahonermann wrote:

I think it's debatable whether this is a bug or not

For C99 through C17, I kind of agree, but for C2x (where the warning is still issued with -Wstrict-prototypes), my understanding is that void foo(void) and void foo() are equivalent; there is no unprototyped declaration. I think the diagnostic should at least be suppressed for C2x since we don't want to encourage programmers to explicitly add void when targeting that standard.

Good catch... -Wstrict-prototypes should be a noop in C2x mode! I'll work on fixing that.

I fixed that issue in ef87865b98fa25af1d2c045bab1268b2a1503374, thanks for catching it.

[manojgupta]

Basically, I'm wondering if you'd be able to enable -fno-knr-function?

Thanks. this looks promising. Any ideas when -fno-knr-function support was added?

[manojgupta]

Unless I probably mis-interpreted something, -fno-knr-functions does not suppress the warning: https://godbolt.org/z/rbEfbbb33

[aaron.ballman]

In D122895#3483163, @manojgupta wrote:

Basically, I'm wondering if you'd be able to enable -fno-knr-function?

Thanks. this looks promising. Any ideas when -fno-knr-function support was added?

Oops, I had a slight typo, it's -fno-knr-functions plural. But it was added 9 days ago in https://github.com/llvm/llvm-project/commit/9955f14aaf9995f6f0f7bf058ac740463003c470, and as of today, using that flag will disable the -Wstrict-prototypes warnings entirely (as will specifying -std=c2x).

[aaron.ballman]

In D122895#3483175, @manojgupta wrote:

Unless I probably mis-interpreted something, -fno-knr-functions does not suppress the warning: https://godbolt.org/z/rbEfbbb33

Godbolt hasn't had the chance to catch up to https://github.com/llvm/llvm-project/commit/ef87865b98fa25af1d2c045bab1268b2a1503374 yet.

[manojgupta]

Tried locally but I still see the warning with -fno-knr-functions. It also says that the argument is unused.

bin/clang --version
clang version 15.0.0 (https://github.com/llvm/llvm-project.git a9d68a5524dea113cace5983697786599cbdce9a)
Target: x86_64-unknown-linux-gnu

$ cat pr.c
void foo(void);

void foo()
{
}
$ bin/clang -c pr.c -Wstrict-prototypes -fno-knr-functions
clang-14: warning: argument unused during compilation: '-fno-knr-functions' [-Wunused-command-line-argument]
pr.c:3:9: warning: a function declaration without a prototype is deprecated in all versions of C [-Wstrict-prototypes]
void foo()

^
 void

1 warning generated.

It works if -fno-knr-functions is passed with Xclang . Is it intentional that -fno-knr-functions is only a cc1 option? That makes it very hard for us to enable it.

$ bin/clang -c pr.c -Wstrict-prototypes -Xclang -fno-knr-functions (no warnings)

[manojgupta]

Following behavior is also surprising:

-Werror -Wimplicit-function-declaration does not rep-promote it to an error either if I suppress it globally with -Wno-error=implicit-function-declaration.

$ bin/clang -c tent.c -Wno-error=implicit-function-declaration -Werror -Wimplicit-function-declaration
tent.c:3:2: warning: call to undeclared function 'tgetent'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
tgetent(0,0);
^
1 warning generated.

This is breaking a lot of upstream configure scripts. I have had problems with less/sed/zip etc. They fail so early that I do not even know how many more packages are broken which is going to be very hard and cumbersome to fix :(..

[aaron.ballman]

In D122895#3484076, @manojgupta wrote:

Tried locally but I still see the warning with -fno-knr-functions. It also says that the argument is unused.

bin/clang --version
clang version 15.0.0 (https://github.com/llvm/llvm-project.git a9d68a5524dea113cace5983697786599cbdce9a)
Target: x86_64-unknown-linux-gnu

$ cat pr.c
void foo(void);

void foo()
{
}
$ bin/clang -c pr.c -Wstrict-prototypes -fno-knr-functions
clang-14: warning: argument unused during compilation: '-fno-knr-functions' [-Wunused-command-line-argument]
pr.c:3:9: warning: a function declaration without a prototype is deprecated in all versions of C [-Wstrict-prototypes]
void foo()

^
 void

1 warning generated.

It works if -fno-knr-functions is passed with Xclang . Is it intentional that -fno-knr-functions is only a cc1 option? That makes it very hard for us to enable it.

$ bin/clang -c pr.c -Wstrict-prototypes -Xclang -fno-knr-functions (no warnings)

No, that's not at all intentional -- it should be exposed as a driver flag. I can reproduce the issue locally and will fix this today (it's very strange because the option is listed as a CoreOption should it should be exposed through the driver). I'm very sorry for the trouble, but thank you for catching this!

In D122895#3484077, @manojgupta wrote:

Following behavior is also surprising:

-Werror -Wimplicit-function-declaration does not rep-promote it to an error either if I suppress it globally with -Wno-error=implicit-function-declaration.

On its face, I agree that it's surprising, but that's the general behavior of -Werror when warning flags default to an error, and is not specific to the changes here: https://godbolt.org/z/ronq687cj

[aaron.ballman]

In D122895#3484097, @aaron.ballman wrote:

In D122895#3484076, @manojgupta wrote:

Tried locally but I still see the warning with -fno-knr-functions. It also says that the argument is unused.

bin/clang --version
clang version 15.0.0 (https://github.com/llvm/llvm-project.git a9d68a5524dea113cace5983697786599cbdce9a)
Target: x86_64-unknown-linux-gnu

$ cat pr.c
void foo(void);

void foo()
{
}
$ bin/clang -c pr.c -Wstrict-prototypes -fno-knr-functions
clang-14: warning: argument unused during compilation: '-fno-knr-functions' [-Wunused-command-line-argument]
pr.c:3:9: warning: a function declaration without a prototype is deprecated in all versions of C [-Wstrict-prototypes]
void foo()

^
 void

1 warning generated.

It works if -fno-knr-functions is passed with Xclang . Is it intentional that -fno-knr-functions is only a cc1 option? That makes it very hard for us to enable it.

$ bin/clang -c pr.c -Wstrict-prototypes -Xclang -fno-knr-functions (no warnings)

No, that's not at all intentional -- it should be exposed as a driver flag. I can reproduce the issue locally and will fix this today (it's very strange because the option is listed as a CoreOption should it should be exposed through the driver). I'm very sorry for the trouble, but thank you for catching this!

Sheesh, I added the driver tests to make sure we don't accept a negated version of the flag, but I didn't add the test to validate that the driver accepted the flag, which is why I didn't catch this before. I've corrected the problem and added test coverage in 786954db06ab253dbd62d059036e06f6bbd9223c. Thanks for letting me know about the issue!

[dexonsmith]

clang/test/Sema/warn-strict-prototypes.m

20

This is a definition, so the compiler knows that there are no parameters. Why would we warn here? Reading https://discourse.llvm.org/t/rfc-enabling-wstrict-prototypes-by-default-in-c/60521/18 it looks to me like an example of what @rnk was referring to, about churning code to add (void) and then return back to () later.

(cc: @steven_wu and @rjmccall as well)

[dexonsmith]

clang/test/Sema/warn-strict-prototypes.m

20

Specifically, ^void() { /* anything */} is the definition of a block with zero parameters. Maybe pedantically it's lacking a prototype, but the compiler knows (since this is the definition) how many parameters there are.

(Same goes for void() { /* anything */ } at global scope; is that triggering -Wstrict-prototypes now too?)

[dexonsmith]

For additional context to my questions above, even though open source clang hasn't been using -Wstrict-prototypes, Xcode has had it on-by-default in new projects since sometime in 2017, with project modernizations to turn it on for old projects.

Warning on block and function definitions such as ^(){} and void f1() {}, which are pedantically lacking a prototype but the compiler knows there are exactly zero parameters, would be super noisy for users.

Unless I read the RFC too quickly, it doesn't look like it's adding any value, since these aren't going to change meaning. Is it possible to revert this part of the change?

[efriedma]

clang/test/Sema/warn-strict-prototypes.m

20

To be clear, you're asking specifically about the following two cases where the behavior with -Wstrict-prototypes changed, right? I don't think this was really discussed in the RFC.

// Block
void (^f1)(void) = ^(){};

// Function definition
void f(void);
void f(){}

Note that the behavior of the following did not change:

void (^f1)(void) = ^{}; // no warning
void f2(){} // warning since clang 11.

[dexonsmith]

clang/test/Sema/warn-strict-prototypes.m

20

Right, specifically those two cases that changed. Thanks for clarifying.

[aaron.ballman]

In D122895#3510165, @dexonsmith wrote:

For additional context to my questions above, even though open source clang hasn't been using -Wstrict-prototypes, Xcode has had it on-by-default in new projects since sometime in 2017, with project modernizations to turn it on for old projects.

Thanks, that's very good to know! And also, thank you for raising the questions here, I appreciate the discussion.

Warning on block and function definitions such as ^(){} and void f1() {}, which are pedantically lacking a prototype but the compiler knows there are exactly zero parameters, would be super noisy for users.

Unless I read the RFC too quickly, it doesn't look like it's adding any value, since these aren't going to change meaning. Is it possible to revert this part of the change?

-Wstrict-prototypes is now a pedantic deprecation warning that fires any time you form a function type which has no prototype, which was discussed in the RFC (https://discourse.llvm.org/t/rfc-enabling-wstrict-prototypes-by-default-in-c/60521/38?u=aaronballman):

Change -Wstrict-prototypes to diagnose functions without a prototype that don’t change behavior in C2x, it remains off-by-default but is automatically enabled by -pedantic as it’s still warning the user about a deprecation.

However, I think the blocks behavior is a bug based on this: https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaType.cpp#L728 and I'd be more than happy to fix that, as I'm not checking that condition here: https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaType.cpp#L5579 which seems like a pretty obvious thing to be checking for before warning about not having a strict prototype.

But I'm pretty insistent on warning about the other case as it does use functions without a prototype and we need *some* blanket warning for use of a deprecated feature for folks who want to be strictly conforming. It sounds like Apple may want to no longer enable -Wstrict-prototypes by default as it's shifted to be a more pedantic warning than it was before -- would that be a viable option for you (can you use project modernizations to turn it back off for old projects)?

[aaron.ballman]

In D122895#3511312, @aaron.ballman wrote:

However, I think the blocks behavior is a bug based on this: https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaType.cpp#L728 and I'd be more than happy to fix that, as I'm not checking that condition here: https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaType.cpp#L5579 which seems like a pretty obvious thing to be checking for before warning about not having a strict prototype.

I fixed this false positive bug in 4be105c98a9c7e083cd878ee1751e11160b97b4a, so blocks (and OpenCL) behavior should now be improved.

[dexonsmith]

In D122895#3511376, @aaron.ballman wrote:

In D122895#3511312, @aaron.ballman wrote:

However, I think the blocks behavior is a bug based on this: https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaType.cpp#L728 and I'd be more than happy to fix that, as I'm not checking that condition here: https://github.com/llvm/llvm-project/blob/main/clang/lib/Sema/SemaType.cpp#L5579 which seems like a pretty obvious thing to be checking for before warning about not having a strict prototype.

I fixed this false positive bug in 4be105c98a9c7e083cd878ee1751e11160b97b4a, so blocks (and OpenCL) behavior should now be improved.

Thanks! I think that's the bigger issue of the two. @steven_wu or @arphaman will have more context though.

In D122895#3511312, @aaron.ballman wrote:

But I'm pretty insistent on warning about the other case as it does use functions without a prototype and we need *some* blanket warning for use of a deprecated feature for folks who want to be strictly conforming. It sounds like Apple may want to no longer enable -Wstrict-prototypes by default as it's shifted to be a more pedantic warning than it was before -- would that be a viable option for you (can you use project modernizations to turn it back off for old projects)?

[EDIT: trimmed the quote to what I was intending to reply to!]

Sure, I'm all for adding a new warning for users that want a pedantic warning. Can it be put behind a separate flag, such as -Wstrict-prototypes-pedantic, which isn't triggered by -Wstrict-prototypes?

Previously, -Wstrict-prototypes was useful for preventing actual bugs in code.

[jyknight]

The warnings for this case aren't great:

int foo();

int
foo(int arg) {
  return 5;
}

results in:

/tmp/test.c:1:5: warning: a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
int foo();
    ^
        void
/tmp/test.c:4:1: warning: a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
foo(int arg) {
^

Two warnings for the problem, instead of a warning and a note, plus, the fix-it hint is incorrect, which the compiler should know, since we see that there are arguments expected.

I'd expect more like:

/tmp/test.c:1:5: warning: a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
int foo();
/tmp/test.c:4:1: note: subsequent declaration specifies arguments.
foo(int arg) {
    ^

[dexonsmith]

In D122895#3511611, @dexonsmith wrote:

Previously, -Wstrict-prototypes was useful for preventing actual bugs in code.

For example, it's important to have a warning that catches code like this:

void f1(void (^block)());

void f2(void) {
  f1(^(int x) { /* do something with x */ });
}

without triggering in cases that are pedantic.

(It also seems unfortunate to regress the false positive rate of this diagnostic before -fstrict-prototypes is available.)

[aaron.ballman]

In D122895#3511611, @dexonsmith wrote:

Sure, I'm all for adding a new warning for users that want a pedantic warning. Can it be put behind a separate flag, such as -Wstrict-prototypes-pedantic, which isn't triggered by -Wstrict-prototypes?

Previously, -Wstrict-prototypes was useful for preventing actual bugs in code.

Doing that would then make -Wstrict-prototypes effectively a no-op (it would still control -Wdeprecated-non-prototype I suppose?), but there were also people who enabled -Wstrict-prototypes because they wanted the pedantic aspects of the warning in cases where it was firing, and those folks would then be losing warning coverage without knowing it. For example:

void f(){}

In prior versions of Clang with -Wstrict-prototypes this would issue a this old-style function definition is not preceded by a prototype diagnostic, but would now be silenced entirely unless the user knew to turn on a different flag.

[aaron.ballman]

In D122895#3511632, @jyknight wrote:

The warnings for this case aren't great:

int foo();

int
foo(int arg) {
  return 5;
}

Yeah, that's not ideal, I'm looking into it to see if I can improve that scenario or not. Thankfully, IMO, such code is likely to be extremely rare. Most people writing that declaration either expect an arbitrary number of args (they really don't want the prototype) and so the definition is extremely suspect that it only accepts one, or they wrote the declaration assuming it would accept *no* args (the C++ behavior) and then the definition becomes flat-out a bug. Do you have evidence this code pattern appears with some frequency?

[dexonsmith]

In D122895#3511649, @aaron.ballman wrote:

In D122895#3511611, @dexonsmith wrote:

Sure, I'm all for adding a new warning for users that want a pedantic warning. Can it be put behind a separate flag, such as -Wstrict-prototypes-pedantic, which isn't triggered by -Wstrict-prototypes?

Previously, -Wstrict-prototypes was useful for preventing actual bugs in code.

Doing that would then make -Wstrict-prototypes effectively a no-op (it would still control -Wdeprecated-non-prototype I suppose?),

Is it necessary to make -Wstrict-prototypes weaker in order to move the newer more pedantic cases to a different name?

but there were also people who enabled -Wstrict-prototypes because they wanted the pedantic aspects of the warning in cases where it was firing, and those folks would then be losing warning coverage without knowing it. For example:

void f(){}

In prior versions of Clang with -Wstrict-prototypes this would issue a this old-style function definition is not preceded by a prototype diagnostic, but would now be silenced entirely unless the user knew to turn on a different flag.

Oh, I thought that would catch bugs like this:

void longfunctionname(){}
void longfunctionnames(int x){ /* do something with x */ }

void g(void) {
  longfunctionname(7); // oops, meant to call longfunctionnames().
}

but if it's entirely pedantic (if the call to longfunctionname(7) would fail to compile) then I agree it'd be better to silence it unless someone asks for -pedantic.

[aaron.ballman]

In D122895#3511646, @dexonsmith wrote:

In D122895#3511611, @dexonsmith wrote:

Previously, -Wstrict-prototypes was useful for preventing actual bugs in code.

For example, it's important to have a warning that catches code like this:

void f1(void (^block)());

void f2(void) {
  f1(^(int x) { /* do something with x */ });
}

without triggering in cases that are pedantic.

(It also seems unfortunate to regress the false positive rate of this diagnostic before -fstrict-prototypes is available.)

-fno-knr-functions is available already today in trunk, so I'm not certain I understand your concern there (or were you unaware we changed the flag name perhaps?).

Your code example is interesting though as I would expect that to trigger -Wdeprecated-non-prototype as well as -Wstrict-prototypes. I'd expect the pedantic warning to complain about the block declaration because it specifies no prototype, and I'd expect the changes behavior warning because that code will break in C2x.

Is it necessary to make -Wstrict-prototypes weaker in order to move the newer more pedantic cases to a different name?

This diagnostic is *extremely* difficult for a whole host of reasons. 1) we need to diagnose function *types* without a prototype, but you form a function type when declaring or defining a function in addition to just using the type in a typedef or a variable declaration. 2) we need to handle function definitions differently; that's the only point at which we know whether the user is defining a function with an identifier list which will change behavior in C2x, 3) we need to handle function declaration merging (which happens for definitions as well as redeclarations). So there's this very convoluted dance where some cases are handled in Sema::GetFullTypeForDeclarator() (this is the only place we trigger the pedantic warning from), some are handled in Sema::ActOnFinishFunctionBody(), and some are handled in Sema::MergeFunctionDecl(). Trying to weaken -Wstrict-prototypes specifically means having to make the decision at the time when the only information we have is what we can glean from the declarator.

Oh, I thought that would catch bugs like this:

void longfunctionname(){}
void longfunctionnames(int x){ /* do something with x */ }

void g(void) {
  longfunctionname(7); // oops, meant to call longfunctionnames().
}

but if it's entirely pedantic (if the call to longfunctionname(7) would fail to compile) then I agree it'd be better to silence it unless someone asks for -pedantic.

The call to longfunctionname(7) would be rejected in C2x and accepted in earlier modes, which is why it gets flagged warning: passing arguments to 'longfunctionname' without a prototype is deprecated in all versions of C and is not supported in C2x. It's worth noting that -Wstrict-prototypes is now in -pedantic explicitly (it shifted from being a Warning to an Extension because it is now a pedantic warning).

[aaron.ballman]

In D122895#3511682, @aaron.ballman wrote:

In D122895#3511632, @jyknight wrote:

The warnings for this case aren't great:

int foo();

int
foo(int arg) {
  return 5;
}

Yeah, that's not ideal, I'm looking into it to see if I can improve that scenario or not.

There's not much to be done about the strict prototype warning for the declaration; the issue is that we need to give the strict prototypes warning when forming the function *type* for the declaration, which is long before we have any idea there's a subsequent definition (also, because this is for forming the type, we don't know what declarations, if any, may be related, so there's no real way to improve the fix-it behavior). However, I think the second warning is just bad wording -- we know we have a function definition with a prototype for this particular diagnostic. However, there's the redeclaration case to consider at the same time. So here's the full test and the best behavior that I can come up with so far:

void foo();
void foo(int arg);

void bar();
void bar(int arg) {}

With -Wstrict-prototypes enabled:

F:\source\llvm-project>llvm\out\build\x64-Debug\bin\clang.exe -fsyntax-only -Wstrict-prototypes "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c"
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:1:9: warning: a function declaration without a prototype
      is deprecated in all versions of C [-Wstrict-prototypes]
void foo();
        ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:2:6: warning: this function declaration with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void foo(int arg);
     ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:4:9: warning: a function declaration without a prototype
      is deprecated in all versions of C [-Wstrict-prototypes]
void bar();
        ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:5:6: warning: this function definition with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void bar(int arg) {}
     ^
4 warnings generated.

With -Wstrict-prototypes disabled:

F:\source\llvm-project>llvm\out\build\x64-Debug\bin\clang.exe -fsyntax-only "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c"
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:1:6: warning: a function declaration without a prototype
      is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
void foo();
     ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:2:6: warning: this function declaration with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void foo(int arg);
     ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:4:6: warning: a function declaration without a prototype
      is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
void bar();
     ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:5:6: warning: this function definition with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void bar(int arg) {}
     ^
4 warnings generated.

It's not ideal, but it's about the most workable solution I can come up with that doesn't regress far more important cases. It'd be nice if we had a note instead of leaning on the previous warning like we're doing, but I still claim this is defensible given how rare the situation is that you'd declare without a prototype and later redeclare (perhaps through a definition) with a non-void prototype. Note (it's easy to miss with the wall of text), the difference between the two runs is that when strict prototypes are enabled, we issue the strict prototype warning on the first declaration and when strict prototypes are disabled, we issue the "is not supported in C2x" diagnostic on the first declaration -- but in either case the intention is to alert the user to which previous declaration has no prototype for the subsequent declaration/definition that caused the issue.

this function declaration|definition with a prototype will change behavior in C2x because of a previous declaration with no prototype is the new diagnostic wording I've got so far, and I'm not strongly tied to it, if you have suggestions to improve it. I would also be happy with this function declaration|definition with a prototype is not supported in C2x because of a previous declaration with no prototype or something along those lines.

[aaron.ballman]

In D122895#3511855, @aaron.ballman wrote:

In D122895#3511646, @dexonsmith wrote:

void f1(void (^block)());

void f2(void) {
  f1(^(int x) { /* do something with x */ });
}

Your code example is interesting though as I would expect that to trigger -Wdeprecated-non-prototype as well as -Wstrict-prototypes. I'd expect the pedantic warning to complain about the block declaration because it specifies no prototype, and I'd expect the changes behavior warning because that code will break in C2x.

I think the current behavior today makes sense but we should see if we can improve it to make *more* sense. With -Wstrict-prototypes, we should complain about the block without a prototype, but the use at the call site is not declaring a conflicting declaration nor is it a call to a function without a prototype but passes arguments (both of those are -Wdeprecated-non-prototype warnings). Instead, it's a new kind of situation that we may want to consider adding additional coverage for under -Wdeprecated-non-prototype based on the same reasoning we used for diagnosing calls to a function without a prototype but pass arguments. This is not specific to blocks, consider:

void func(void (*fp)());
void do_it(int i);

int main(void) {
  func(do_it); // It'd be nice to diagnose this too, but we don't today
}

[aaron.ballman]

In D122895#3512341, @aaron.ballman wrote:

I think the current behavior today makes sense but we should see if we can improve it to make *more* sense. With -Wstrict-prototypes, we should complain about the block without a prototype, but the use at the call site is not declaring a conflicting declaration nor is it a call to a function without a prototype but passes arguments (both of those are -Wdeprecated-non-prototype warnings). Instead, it's a new kind of situation that we may want to consider adding additional coverage for under -Wdeprecated-non-prototype based on the same reasoning we used for diagnosing calls to a function without a prototype but pass arguments. This is not specific to blocks, consider:

void func(void (*fp)());
void do_it(int i);

int main(void) {
  func(do_it); // It'd be nice to diagnose this too, but we don't today
}

Mostly as a note to myself (but others can definitely chime in if they think I'm wrong here), I *think* the correct way to handle both blocks and function pointers is to add new AssignConvertType enumerators for IncompatibleC2xFunctionPointer and IncompatibleC2xBlockPointer to represent an assignment conversion that is compatible today but will be incompatible in C2x. Then functions like checkPointerTypesForAssignment() and checkBlockPointerTypesForAssignment() can return the new value, which DiagnoseAssignmentResult() can use to determine whether to diagnose a potential behavior change or not.

[aaron.ballman]

In D122895#3512314, @aaron.ballman wrote:

In D122895#3511682, @aaron.ballman wrote:

In D122895#3511632, @jyknight wrote:

The warnings for this case aren't great:

int foo();

int
foo(int arg) {
  return 5;
}

Yeah, that's not ideal, I'm looking into it to see if I can improve that scenario or not.

There's not much to be done about the strict prototype warning for the declaration; the issue is that we need to give the strict prototypes warning when forming the function *type* for the declaration, which is long before we have any idea there's a subsequent definition (also, because this is for forming the type, we don't know what declarations, if any, may be related, so there's no real way to improve the fix-it behavior). However, I think the second warning is just bad wording -- we know we have a function definition with a prototype for this particular diagnostic. However, there's the redeclaration case to consider at the same time. So here's the full test and the best behavior that I can come up with so far:

void foo();
void foo(int arg);

void bar();
void bar(int arg) {}

With -Wstrict-prototypes enabled:

F:\source\llvm-project>llvm\out\build\x64-Debug\bin\clang.exe -fsyntax-only -Wstrict-prototypes "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c"
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:1:9: warning: a function declaration without a prototype
      is deprecated in all versions of C [-Wstrict-prototypes]
void foo();
        ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:2:6: warning: this function declaration with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void foo(int arg);
     ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:4:9: warning: a function declaration without a prototype
      is deprecated in all versions of C [-Wstrict-prototypes]
void bar();
        ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:5:6: warning: this function definition with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void bar(int arg) {}
     ^
4 warnings generated.

With -Wstrict-prototypes disabled:

F:\source\llvm-project>llvm\out\build\x64-Debug\bin\clang.exe -fsyntax-only "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c"
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:1:6: warning: a function declaration without a prototype
      is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
void foo();
     ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:2:6: warning: this function declaration with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void foo(int arg);
     ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:4:6: warning: a function declaration without a prototype
      is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
void bar();
     ^
         void
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.c:5:6: warning: this function definition with a prototype
      will change behavior in C2x because of a previous declaration with no prototype [-Wdeprecated-non-prototype]
void bar(int arg) {}
     ^
4 warnings generated.

It's not ideal, but it's about the most workable solution I can come up with that doesn't regress far more important cases. It'd be nice if we had a note instead of leaning on the previous warning like we're doing, but I still claim this is defensible given how rare the situation is that you'd declare without a prototype and later redeclare (perhaps through a definition) with a non-void prototype. Note (it's easy to miss with the wall of text), the difference between the two runs is that when strict prototypes are enabled, we issue the strict prototype warning on the first declaration and when strict prototypes are disabled, we issue the "is not supported in C2x" diagnostic on the first declaration -- but in either case the intention is to alert the user to which previous declaration has no prototype for the subsequent declaration/definition that caused the issue.

this function declaration|definition with a prototype will change behavior in C2x because of a previous declaration with no prototype is the new diagnostic wording I've got so far, and I'm not strongly tied to it, if you have suggestions to improve it. I would also be happy with this function declaration|definition with a prototype is not supported in C2x because of a previous declaration with no prototype or something along those lines.

I put up a review at https://reviews.llvm.org/D125814 going in this direction and added you both as reviewers.

[dexonsmith]

In D122895#3511855, @aaron.ballman wrote:

(It also seems unfortunate to regress the false positive rate of this diagnostic before -fstrict-prototypes is available.)

-fno-knr-functions is available already today in trunk, so I'm not certain I understand your concern there (or were you unaware we changed the flag name perhaps?).

That's right, I missed it. Thanks for pointing it out!

clang/docs/ReleaseNotes.rst

- ``-Wliteral-range`` will warn on floating-point equality comparisons with
   ``(float) f == 0.1`` is always false.
 - ``-Winline-namespace-reopened-noninline`` now takes into account that the
   ``inline`` keyword must appear on the original but not necessarily all
   extension definitions of an inline namespace and therefore points its note
   at the original definition. This fixes `Issue 50794 (PR51452)
   <https://github.com/llvm/llvm-project/issues/50794>`_.
 - ``-Wunused-but-set-variable`` now also warns if the variable is only used
   by unary operators.
+- Modified the behavior of ``-Wstrict-prototypes`` and added a new, related
+  diagnostic ``-Wdeprecated-non-prototype``. The strict prototypes warning will
+  now only diagnose deprecated declarations and definitions of functions
+  without a prototype where the behavior in C2x will remain correct. This
+  diagnostic remains off by default but is now enabled via ``-pedantic`` due to
+  it being a deprecation warning. ``-Wdeprecated-non-prototype`` will diagnose
+  cases where the deprecated declarations or definitions of a function without
+  a prototype will change behavior in C2x. This diagnostic is grouped under the
+  ``-Wstrict-prototypes`` warning group, but is enabled by default.
+- ``-Wmisexpect`` warns when the branch weights collected during profiling
+  conflict with those added by ``llvm.expect``.
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 - Improve __builtin_dump_struct:
   - Support bitfields in struct and union.
   - Improve the dump format, dump both bitwidth(if its a bitfield) and field value.
   - Remove anonymous tag locations.
   - Beautify dump format, add indent for nested struct and struct members.

clang/include/clang/Basic/DiagnosticGroups.td

 def PrivateModule : DiagGroup<"private-module">;
 
 def CXX11InlineNamespace : DiagGroup<"c++11-inline-namespace">;
 def InlineNamespaceReopenedNoninline
     : DiagGroup<"inline-namespace-reopened-noninline">;
 def InvalidNoreturn : DiagGroup<"invalid-noreturn">;
 def InvalidSourceEncoding : DiagGroup<"invalid-source-encoding">;
 def KNRPromotedParameter : DiagGroup<"knr-promoted-parameter">;
+def DeprecatedNonPrototype : DiagGroup<"deprecated-non-prototype">;
+def StrictPrototypes : DiagGroup<"strict-prototypes", [DeprecatedNonPrototype]>;
 def : DiagGroup<"init-self">;
 def : DiagGroup<"inline">;
 def : DiagGroup<"invalid-pch">;
 def GNULabelsAsValue : DiagGroup<"gnu-label-as-value">;
 def LiteralRange : DiagGroup<"literal-range">;
 def LocalTypeTemplateArgs : DiagGroup<"local-type-template-args",
                                       [CXX98CompatLocalTypeTemplateArgs]>;
 def RangeLoopConstruct : DiagGroup<"range-loop-construct">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_sentinel_here : Note<
   "%select{function|method|block}0 has been explicitly marked sentinel here">;
 def warn_missing_prototype : Warning<
   "no previous prototype for function %0">,
   InGroup<DiagGroup<"missing-prototypes">>, DefaultIgnore;
 def note_declaration_not_a_prototype : Note<
   "this declaration is not a prototype; add %select{'void'|parameter declarations}0 "
   "to make it %select{a prototype for a zero-parameter function|one}0">;
-def warn_strict_prototypes : Warning<
-  "this %select{function declaration is not|block declaration is not|"
-  "old-style function definition is not preceded by}0 a prototype">,
-  InGroup<DiagGroup<"strict-prototypes">>, DefaultIgnore;
+// This is not actually an extension, but we only want it to be enabled in
+// -pedantic mode and this is the most direct way of accomplishing that.
+def warn_strict_prototypes : Extension<
+  "a %select{function|block}0 declaration without a prototype is deprecated "
+  "%select{in all versions of C|}0">, InGroup<StrictPrototypes>;
+def warn_non_prototype_changes_behavior : Warning<
+  "this function declaration without a prototype is deprecated in all versions "
+  "of C and changes behavior in C2x">, InGroup<DeprecatedNonPrototype>;
+def warn_prototype_changes_behavior : Warning<
+  "this function declaration with a prototype changes behavior in C2x because "
+  "it is %select{preceded|followed}0 by a function without a prototype">,
+  InGroup<DeprecatedNonPrototype>;
+def note_func_decl_changes_behavior : Note<
+  "this function declaration without a prototype changes behavior in C2x">;
 def warn_missing_variable_declarations : Warning<
   "no previous extern declaration for non-static variable %0">,
   InGroup<DiagGroup<"missing-variable-declarations">>, DefaultIgnore;
 def note_static_for_internal_linkage : Note<
   "declare 'static' if the %select{variable|function}0 is not intended to be "
   "used outside of this translation unit">;
 def err_static_data_member_reinitialization :
   Error<"static data member %0 already has an initializer">;

clang/lib/Sema/SemaDecl.cpp

     if (!canFullyTypeCheckRedeclaration(New, Old, NewQType, OldQType))
       return false;
 
     // Fall through for conflicting redeclarations and redefinitions.
   }
 
   // C: Function types need to be compatible, not identical. This handles
   // duplicate function decls like "void f(int); void f(enum X);" properly.
-  if (!getLangOpts().CPlusPlus &&
-      Context.typesAreCompatible(OldQType, NewQType)) {
-    const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
-    const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
-    const FunctionProtoType *OldProto = nullptr;
-    if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
-        (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
-      // The old declaration provided a function prototype, but the
-      // new declaration does not. Merge in the prototype.
-      assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
-      SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
-      NewQType =
-          Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
-                                  OldProto->getExtProtoInfo());
-      New->setType(NewQType);
-      New->setHasInheritedPrototype();
-
-      // Synthesize parameters with the same types.
-      SmallVector<ParmVarDecl*, 16> Params;
-      for (const auto &ParamType : OldProto->param_types()) {
-        ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(),
-                                                 SourceLocation(), nullptr,
-                                                 ParamType, /*TInfo=*/nullptr,
-                                                 SC_None, nullptr);
-        Param->setScopeInfo(0, Params.size());
-        Param->setImplicit();
-        Params.push_back(Param);
+  if (!getLangOpts().CPlusPlus) {
+    // If we are merging two functions where only one of them has a prototype,
+    // we may have enough information to decide to issue a diagnostic that the
+    // function without a protoype will change behavior in C2x. This handles
+    // cases like:
+    //   void i(); void i(int j);
+    //   void i(int j); void i();
+    //   void i(); void i(int j) {}
+    // See ActOnFinishFunctionBody() for other cases of the behavior change
+    // diagnostic. See GetFullTypeForDeclarator() for handling of a function
+    // type without a prototype.
+    if (New->hasWrittenPrototype() != Old->hasWrittenPrototype()) {
+      const FunctionDecl *WithProto, *WithoutProto;
+      if (New->hasWrittenPrototype()) {
+        WithProto = New;
+        WithoutProto = Old;
+      } else {
+        WithProto = Old;
+        WithoutProto = New;
       }
 
-      New->setParams(Params);
+      if (WithProto->getNumParams() != 0) {
+        // The function definition has parameters, so this will change
+        // behavior in C2x.
+        // FIXME: The declaration may have already been diagnosed as being
+        // deprecated in GetFullTypeForDeclarator() if it had no arguments,
+        // but there's no way to test for the "changes behavior" condition in
+        // SemaType.cpp when forming the declaration's function type. So, we
+        // do this awkward dance instead.
+        //
+        // If we already warned about about the function without a prototype
+        // being deprecated, add a note that it also changes behavior. If we
+        // didn't warn about it being deprecated (because the diagnostic is
+        // not enabled), warn now that it is deprecated and changes behavior.
+        bool AddNote = false;
+        if (Diags.isIgnored(diag::warn_strict_prototypes,
+                            WithoutProto->getLocation())) {
+          if (WithoutProto->getBuiltinID() == 0 &&
+              !WithoutProto->isImplicit()) {
+            PartialDiagnostic PD =
+                PDiag(diag::warn_non_prototype_changes_behavior);
+            if (TypeSourceInfo *TSI = WithoutProto->getTypeSourceInfo()) {
+              if (auto FTL = TSI->getTypeLoc().getAs<FunctionNoProtoTypeLoc>())
+                PD << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
+            }
+            Diag(WithoutProto->getLocation(), PD);
+          }
+        } else {
+          AddNote = true;
+        }
+
+        // Because the function with a prototype has parameters but a previous
+        // declaration had none, the function with the prototype will also
+        // change behavior in C2x.
+        if (WithProto->getBuiltinID() == 0 && !WithProto->isImplicit()) {
+          Diag(WithProto->getLocation(), diag::warn_prototype_changes_behavior)
+              << SourceMgr.isBeforeInTranslationUnit(
+                     WithProto->getLocation(), WithoutProto->getLocation());
+          if (AddNote && WithoutProto->getBuiltinID() == 0)
+            Diag(WithoutProto->getLocation(),
+                 diag::note_func_decl_changes_behavior);
+        } else if (AddNote && WithoutProto->getBuiltinID() == 0 &&
+                   !WithoutProto->isImplicit()) {
+          // If we were supposed to add a note but the function with a
+          // prototype is a builtin, we have nothing to attach the note to, so
+          // we issue a warning instead.
+          Diag(WithoutProto->getLocation(),
+               diag::warn_non_prototype_changes_behavior);
+        }
+      }
     }
 
-    return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
+    if (Context.typesAreCompatible(OldQType, NewQType)) {
+      const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
+      const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
+      const FunctionProtoType *OldProto = nullptr;
+      if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
+          (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
+        // The old declaration provided a function prototype, but the
+        // new declaration does not. Merge in the prototype.
+        assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
+        SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
+        NewQType =
+            Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
+                                    OldProto->getExtProtoInfo());
+        New->setType(NewQType);
+        New->setHasInheritedPrototype();
+
+        // Synthesize parameters with the same types.
+        SmallVector<ParmVarDecl *, 16> Params;
+        for (const auto &ParamType : OldProto->param_types()) {
+          ParmVarDecl *Param = ParmVarDecl::Create(
+              Context, New, SourceLocation(), SourceLocation(), nullptr,
+              ParamType, /*TInfo=*/nullptr, SC_None, nullptr);
+          Param->setScopeInfo(0, Params.size());
+          Param->setImplicit();
+          Params.push_back(Param);
+        }
+
+        New->setParams(Params);
+      }
+
+      return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
+    }
   }
 
   // Check if the function types are compatible when pointer size address
   // spaces are ignored.
   if (Context.hasSameFunctionTypeIgnoringPtrSizes(OldQType, NewQType))
     return false;
 
   // GNU C permits a K&R definition to follow a prototype declaration

           };
           Diag(FD->getTypeSpecStartLoc(),
                diag::note_static_for_internal_linkage)
               << /* function */ 1
               << (FD->getStorageClass() == SC_None
                       ? FixItHint::CreateInsertion(findBeginLoc(), "static ")
                       : FixItHint{});
         }
+      }
 
-        // GNU warning -Wstrict-prototypes
-        //   Warn if K&R function is defined without a previous declaration.
-        //   This warning is issued only if the definition itself does not
-        //   provide a prototype. Only K&R definitions do not provide a
-        //   prototype.
-        if (!FD->hasWrittenPrototype()) {
-          TypeSourceInfo *TI = FD->getTypeSourceInfo();
-          TypeLoc TL = TI->getTypeLoc();
-          FunctionTypeLoc FTL = TL.getAsAdjusted<FunctionTypeLoc>();
-          Diag(FTL.getLParenLoc(), diag::warn_strict_prototypes) << 2;
+      // If the function being defined does not have a prototype, then we may
+      // need to diagnose it as changing behavior in C2x because we now know
+      // whether the function accepts arguments or not. This only handles the
+      // case where the definition has no prototype but does have parameters
+      // and either there is no previous potential prototype, or the previous
+      // potential prototype also has no actual prototype. This handles cases
+      // like:
+      //   void f(); void f(a) int a; {}
+      //   void g(a) int a; {}
+      // See MergeFunctionDecl() for other cases of the behavior change
+      // diagnostic. See GetFullTypeForDeclarator() for handling of a function
+      // type without a prototype.
+      if (!FD->hasWrittenPrototype() && FD->getNumParams() != 0 &&
+          (!PossiblePrototype || (!PossiblePrototype->hasWrittenPrototype() &&
+                                  !PossiblePrototype->isImplicit()))) {
+        // The function definition has parameters, so this will change behavior
+        // in C2x. If there is a possible prototype, it comes before the
+        // function definition.
+        // FIXME: The declaration may have already been diagnosed as being
+        // deprecated in GetFullTypeForDeclarator() if it had no arguments, but
+        // there's no way to test for the "changes behavior" condition in
+        // SemaType.cpp when forming the declaration's function type. So, we do
+        // this awkward dance instead.
+        //
+        // If we have a possible prototype and it declares a function with a
+        // prototype, we don't want to diagnose it; if we have a possible
+        // prototype and it has no prototype, it may have already been
+        // diagnosed in SemaType.cpp as deprecated depending on whether
+        // -Wstrict-prototypes is enabled. If we already warned about it being
+        // deprecated, add a note that it also changes behavior. If we didn't
+        // warn about it being deprecated (because the diagnostic is not
+        // enabled), warn now that it is deprecated and changes behavior.
+        bool AddNote = false;
+        if (PossiblePrototype) {
+          if (Diags.isIgnored(diag::warn_strict_prototypes,
+                              PossiblePrototype->getLocation())) {
+
+            PartialDiagnostic PD =
+                PDiag(diag::warn_non_prototype_changes_behavior);
+            if (TypeSourceInfo *TSI = PossiblePrototype->getTypeSourceInfo()) {
+              if (auto FTL = TSI->getTypeLoc().getAs<FunctionNoProtoTypeLoc>())
+                PD << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
+            }
+            Diag(PossiblePrototype->getLocation(), PD);
+          } else {
+            AddNote = true;
+          }
         }
+
+        // Because this function definition has no prototype and it has
+        // parameters, it will definitely change behavior in C2x.
+        Diag(FD->getLocation(), diag::warn_non_prototype_changes_behavior);
+        if (AddNote)
+          Diag(PossiblePrototype->getLocation(),
+               diag::note_func_decl_changes_behavior);
       }
 
       // Warn on CPUDispatch with an actual body.
       if (FD->isMultiVersion() && FD->hasAttr<CPUDispatchAttr>() && Body)
         if (const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
           if (!CmpndBody->body_empty())
             Diag(CmpndBody->body_front()->getBeginLoc(),
                  diag::warn_dispatch_body_ignored);

clang/lib/Sema/SemaType.cpp

     }
   }
 
   if (ExpectNoDerefChunk)
     S.Diag(state.getDeclarator().getBeginLoc(),
            diag::warn_noderef_on_non_pointer_or_array);
 
   // GNU warning -Wstrict-prototypes
-  //   Warn if a function declaration is without a prototype.
+  //   Warn if a function declaration or definition is without a prototype.
   //   This warning is issued for all kinds of unprototyped function
   //   declarations (i.e. function type typedef, function pointer etc.)
   //   C99 6.7.5.3p14:
   //   The empty list in a function declarator that is not part of a definition
   //   of that function specifies that no information about the number or types
   //   of the parameters is supplied.
+  // See ActOnFinishFunctionBody() and MergeFunctionDecl() for handling of
+  // function declarations whose behavior changes in C2x.
   if (!LangOpts.CPlusPlus &&
-      D.getFunctionDefinitionKind() == FunctionDefinitionKind::Declaration) {
+      (D.getFunctionDefinitionKind() == FunctionDefinitionKind::Declaration ||
+       D.getFunctionDefinitionKind() == FunctionDefinitionKind::Definition)) {
     bool IsBlock = false;
     for (const DeclaratorChunk &DeclType : D.type_objects()) {
       switch (DeclType.Kind) {
       case DeclaratorChunk::BlockPointer:
         IsBlock = true;
         break;
       case DeclaratorChunk::Function: {
         const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;

clang/test/CodeGen/2009-06-01-addrofknr.c

-// RUN: %clang_cc1 %s -o %t -emit-llvm -verify
-// expected-no-diagnostics
+// RUN: %clang_cc1 %s -o %t -emit-llvm -verify -std=c89
 // PR4289
 
 struct funcptr {
   int (*func)();
 };
 
-static int func(f)
+static int func(f) // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
   void *f;
 {
   return 0;
 }
 
 int
 main(int argc, char *argv[])
 {
   struct funcptr fp;
 
   fp.func = &func;
   fp.func = func;
 }

clang/test/FixIt/fixit.c

-// RUN: %clang_cc1 -pedantic -Wunused-label -verify -x c %s
+// RUN: %clang_cc1 -pedantic -Wunused-label -Wno-deprecated-non-prototype -verify -x c %s
 // RUN: cp %s %t
 // RUN: not %clang_cc1 -pedantic -Wunused-label -fixit -x c %t
-// RUN: %clang_cc1 -pedantic -Wunused-label -Werror -x c %t
+// RUN: %clang_cc1 -pedantic -Wunused-label -Wno-deprecated-non-prototype -Werror -x c %t
 // RUN: grep -v CHECK %t | FileCheck %t
 
 /* This is a test of the various code modification hints that are
    provided as part of warning or extension diagnostics. All of the
    warnings will be fixed by -fixit, and the resulting file should
    compile cleanly with -Werror -pedantic. */
 
 // FIXME: FIX-IT should add #include <string.h>?

clang/test/Parser/declarators.c

-// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic
+// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -std=c99
 
 extern int a1[];
 
-void f0();
+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-warning {{type specifier missing, defaults to '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);
 
 int *A;
 
 struct str;
 
 void test2(int *P, int A) {
   struct str;
 
   // Hard case for array decl, not Array[*].
   int Array[*(int*)P+A];
 }
 
 typedef int atype;
-void test3(x, 
+void test3(x,            /* expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}} */
            atype         /* expected-error {{unexpected type name 'atype': expected identifier}} */
           ) int x, atype; {}
 
-void test4(x, x) int x; {} /* expected-error {{redefinition of parameter 'x'}} */
+void test4(x, x) int x; {} // expected-error {{redefinition of parameter 'x'}} \
+                           // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 
 
 // PR3031
 int (test5), ;  // expected-error {{expected identifier or '('}}
 
 
 
 // PR3963 & rdar://6759604 - test error recovery for mistyped "typenames".
 
 foo_t *d;      // expected-error {{unknown type name 'foo_t'}}
 foo_t a;   // expected-error {{unknown type name 'foo_t'}}
-int test6() { return a; }  // a should be declared.
+int test6() { /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
+  return a; // a should be declared.
+}
 
 // Use of tagged type without tag. rdar://6783347
 struct xyz { int y; };
 enum myenum { ASDFAS };
 xyz b;         // expected-error {{must use 'struct' tag to refer to type 'xyz'}}
 myenum c;      // expected-error {{must use 'enum' tag to refer to type 'myenum'}}
 
-float *test7() {
+float *test7(void) {
   // We should recover 'b' by parsing it with a valid type of "struct xyz", which
   // 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() { return a; }  // a should be be marked invalid, no diag.
+struct xyz test8(void) { return a; }  // a should be be marked invalid, no diag.
 
 
 // Verify that implicit int still works.
 static f;      // expected-warning {{type specifier missing, defaults to 'int'}}
 static g = 4;  // expected-warning {{type specifier missing, defaults to 'int'}}
 static h        // expected-warning {{type specifier missing, defaults to '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}}
 };
 
 // PR6208
 struct test10 { int a; } static test10x;
 struct test11 { int a; } const test11x;
 
 // PR6216
-void test12() {
+void test12(void) {
   (void)__builtin_offsetof(struct { char c; int i; }, i);
 }
 
 // rdar://7608537
 struct test13 { int a; } (test13x);
 
 // <rdar://problem/8044088>
 struct X<foo::int> { }; // expected-error{{expected identifier or '('}}
 
 
 // PR7617 - error recovery on missing ;.
 
-void test14()  // expected-error {{expected ';' after top level declarator}}
+void test14(void)  // expected-error {{expected ';' after top level declarator}}
 
-void test14a();
+void test14a(void);
 void *test14b = (void*)test14a; // Make sure test14a didn't get skipped.
 
 // rdar://problem/8358508
-long struct X { int x; } test15(); // expected-error {{'long struct' is invalid}}
-
-void test16(i) int i j; { } // expected-error {{expected ';' at end of declaration}}
-void test17(i, j) int i, j k; { } // expected-error {{expected ';' at end of declaration}}
-void knrNoSemi(i) int i { } // expected-error {{expected ';' at end of declaration}}
+long struct X { int x; } test15(void); // expected-error {{'long struct' is invalid}}
 
+void test16(i) int i j; { } // expected-error {{expected ';' at end of declaration}} \
+                            // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
+void test17(i, j) int i, j k; { } // expected-error {{expected ';' at end of declaration}} \
+                                  // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
+void knrNoSemi(i) int i { } // expected-error {{expected ';' at end of declaration}} \
+                            // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 
 // PR12595
-void test18() {
+void test18(void) {
   int x = 4+(5-12));  // expected-error {{extraneous ')' before ';'}}
 }
 
 enum E1 { e1 }: // expected-error {{expected ';'}}
 struct EnumBitfield { // expected-warning {{struct without named members is a GNU extension}}
   enum E2 { e2 } : 4; // ok
   struct S { int n; }: // expected-error {{expected ';'}}
                        // expected-warning@-1 {{declaration does not declare anything}}

clang/test/Parser/knr_parameter_attributes.c

-// RUN: %clang_cc1 -fsyntax-only -W -Wall -Werror -verify %s
+// RUN: %clang_cc1 -fsyntax-only -W -Wall -Wno-deprecated-non-prototype -Werror -verify %s -std=c99
 // expected-no-diagnostics
 
 int f(int i __attribute__((__unused__)))
 {
     return 0;
 }
 int g(i)
     int i __attribute__((__unused__));
 {
     return 0;
 }

clang/test/Parser/opencl-kernel.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
-// expected-no-diagnostics
 
-__kernel void test()
+__kernel void test() // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 {
 }
 
-kernel void test1()
+kernel void test1() // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 {
 }

clang/test/Parser/traditional_arg_scope.c

-// RUN: %clang_cc1 -fsyntax-only %s -verify
+// RUN: %clang_cc1 -fsyntax-only %s -verify -Wno-deprecated-non-prototype -std=c99
 
 int x(a) int a; {return a;}
 int y(b) int b; {return a;} // expected-error {{use of undeclared identifier}}
 
 // PR2332
 int a(a)int a;{a=10;return a;}

clang/test/Sema/arg-duplicate.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c99
 
-int f3(y, x, 
+int f3(y, x,       // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
        x)          // expected-error {{redefinition of parameter}}
   int y, 
       x,           // expected-note {{previous declaration is here}}
       x;           // expected-error {{redefinition of parameter}}
 {
   return x + y; 
 } 
 
 void f4(void) { 
   f3 (1, 1, 2, 3, 4); // expected-warning{{too many arguments}}
 }
 

clang/test/Sema/block-return.c

bptr foo5(int j) {
   return ^{ i=0; };  // expected-error {{returning block that lives on the local stack}}
   return (^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
   return (void*)(^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
 }
 
 int (*funcptr3[5])(long);
 int sz8 = sizeof(^int (*[5])(long) {return funcptr3;}); // expected-error {{block cannot return array type}} expected-warning {{incompatible pointer to integer conversion}}
 int sz9 = sizeof(^int(*())()[3]{ }); // expected-error {{function cannot return array type}}
+                                     // expected-warning@-1 2 {{a function declaration without a prototype is deprecated in all versions of C}}
 
 void foo6(void) {
   int (^b)(int) __attribute__((noreturn));
   b = ^ (int i) __attribute__((noreturn)) { return 1; };  // expected-error {{block declared 'noreturn' should not return}}
   b(1);
   int (^c)(void) __attribute__((noreturn)) = ^ __attribute__((noreturn)) { return 100; }; // expected-error {{block declared 'noreturn' should not return}}
 }
 

clang/test/Sema/implicit-decl.c

void func(void) {
    if (_CFCalendarDecomposeAbsoluteTimeV(compDesc, vector, compCount)) { // expected-error {{implicit declaration of function '_CFCalendarDecomposeAbsoluteTimeV' is invalid in C99}} expected-note {{previous implicit declaration}}
    }
 
    printg("Hello, World!\n"); // expected-error{{implicit declaration of function 'printg' is invalid in C99}} \
                               // expected-note{{did you mean 'printf'?}}
 
   __builtin_is_les(1, 3); // expected-error{{use of unknown builtin '__builtin_is_les'}}
 }
-Boolean _CFCalendarDecomposeAbsoluteTimeV(const char *componentDesc, int32_t **vector, int32_t count) { // expected-error {{conflicting types}}
+// The implicit declaration for this has no prototype.
+Boolean _CFCalendarDecomposeAbsoluteTimeV(const char *componentDesc, int32_t **vector, int32_t count) { // expected-error {{conflicting types}} \
+                                                                                                        // expected-warning {{this function declaration with a prototype changes behavior in C2x because it is preceded by a function without a prototype}}
  return 0;
 }
 
 
 // Test the typo-correction callback in Sema::ImplicitlyDefineFunction
 extern int sformatf(char *str, __const char *__restrict __format, ...); // expected-note{{'sformatf' declared here}}
 void test_implicit(void) {
   int formats = 0;
   formatd("Hello, World!\n"); // expected-error{{implicit declaration of function 'formatd' is invalid in C99}} \
                               // expected-note{{did you mean 'sformatf'?}}
 }

clang/test/Sema/knr-def-call.c

 // RUN: %clang_cc1 -triple i386-pc-unknown -Wconversion -Wliteral-conversion -fsyntax-only -verify %s
 
 // C DR #316, PR 3626.
-void f0(a, b, c, d) int a,b,c,d; {}
+void f0(a, b, c, d) int a,b,c,d; {} // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 void t0(void) {
   f0(1);  // expected-warning{{too few arguments}}
 }
 
-void f1(a, b) int a, b; {}
+void f1(a, b) int a, b; {} // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 void t1(void) {
   f1(1, 2, 3); // expected-warning{{too many arguments}}
 }
 
-void f2(float); // expected-note{{previous declaration is here}}
-void f2(x) float x; { } // expected-warning{{promoted type 'double' of K&R function parameter is not compatible with the parameter type 'float' declared in a previous prototype}}
+void f2(float); // expected-note{{previous declaration is here}} \
+                   expected-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
+void f2(x) float x; { } // expected-warning{{promoted type 'double' of K&R function parameter is not compatible with the parameter type 'float' declared in a previous prototype}} \
+                           expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 
 typedef void (*f3)(void);
 f3 t3(int b) { return b? f0 : f1; } // okay
 
 // <rdar://problem/8193107>
 void f4() {
-    char *rindex();
+    char *rindex(); // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 }
 
-char *rindex(s, c)
+char *rindex(s, c) // // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
      register char *s, c; // expected-warning{{promoted type 'char *' of K&R function parameter is not compatible with the parameter type 'const char *' declared in a previous prototype}}
 {
   return 0;
 }
 
 // PR8314
-void proto(int);
-void proto(x)
+void proto(int); // expected-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
+void proto(x) // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
      int x;
 {
 }
 
 void use_proto() {
   proto(42.1); // expected-warning{{implicit conversion from 'double' to 'int' changes value from 42.1 to 42}}
   (&proto)(42.1); // expected-warning{{implicit conversion from 'double' to 'int' changes value from 42.1 to 42}}
 }
 
 // PR31020
-void func(short d) __attribute__((cdecl)); // expected-note{{previous declaration is here}}
-void __attribute__((cdecl)) func(d)
+void func(short d) __attribute__((cdecl)); // expected-note{{previous declaration is here}} \
+                                              expected-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
+void __attribute__((cdecl)) func(d) // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
   short d; // expected-warning{{promoted type 'int' of K&R function parameter is not compatible with the parameter type 'short' declared in a previous prototype}}
 {}

clang/test/Sema/knr-variadic-def.c

-// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
-// expected-no-diagnostics
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s -std=c99
 // PR4287
 
 #include <stdarg.h>
 char *foo = "test";
-int test(char*,...);
+int test(char*,...); // expected-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
 
-int test(fmt)
+int test(fmt) // expected-note {{this function declaration without a prototype changes behavior in C2x}}
         char*fmt;
 {
         va_list ap;
         char*a;
         int x;
 
         va_start(ap,fmt);
         a=va_arg(ap,char*);
         x=(a!=foo);
         va_end(ap);
         return x;
 }
 
-void exit();
+// We get two diagnostics here because one comes from -Wstrict-prototypes and
+// the other comes from -Wdeprecated-non-prototype.
+void exit(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
+             // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 
-int main(argc,argv)
+int main(argc,argv) // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
         int argc;char**argv;
 {
         exit(test("",foo));
 }
 

clang/test/Sema/vfprintf-valid-redecl.c

-// RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify
-// RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify -DPREDECLARE
+// RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify -std=c99
+// RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify -DPREDECLARE -std=c99
 
 #ifdef PREDECLARE
 // PR16344
 // Clang has defined 'vfprint' in builtin list. If the following line occurs before any other
 // `vfprintf' in this file, and we getPreviousDecl()->getTypeSourceInfo() on it, then we will
 // get a null pointer since the one in builtin list doesn't has valid TypeSourceInfo.
 int vfprintf(void) { return 0; } // expected-warning {{requires inclusion of the header <stdio.h>}}
 #endif
 
 // PR4290
 // The following declaration is compatible with vfprintf, so we shouldn't
 // reject.
-int vfprintf();
+int vfprintf(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 #ifndef PREDECLARE
 // expected-warning@-2 {{requires inclusion of the header <stdio.h>}}
 #endif

clang/test/Sema/warn-deprecated-non-prototype.c

+// RUN: %clang_cc1 -fsyntax-only -verify=both,expected %s
+// RUN: %clang_cc1 -fsyntax-only -Wstrict-prototypes -verify=both,strict %s
+
+// Test both with and without -Wstrict-prototypes because there are complicated
+// interactions between it and -Wdeprecated-non-prototype.
+
+// Off by default warnings, enabled by -pedantic or -Wstrict-prototypes
+void other_func();   // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+void other_func() {} // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+
+void never_defined(); // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+
+typedef void (*fp)(); // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+
+void blerp(
+  void (*func_ptr)() // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+);
+
+void whatever(void) {
+  extern void hoo_boy(); // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+}
+
+void again() {} // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+
+// On by default warnings
+void func();                 // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}} \
+                                strict-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
+                                strict-note {{this function declaration without a prototype changes behavior in C2x}}
+void func(a, b) int a, b; {} // both-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
+
+void one_more(a, b) int a, b; {} // both-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
+
+void sheesh(int a);      // both-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
+void sheesh(a) int a; {} // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}} \
+                            strict-note {{this function declaration without a prototype changes behavior in C2x}}
+
+void another(); // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+
+int main(void) {
+  another(1, 2); // OK for now
+}
+
+void order1();        // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}} \
+                         strict-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
+                         strict-note {{this function declaration without a prototype changes behavior in C2x}}
+void order1(int i);   // both-warning {{this function declaration with a prototype changes behavior in C2x because it is preceded by a function without a prototype}}
+
+void order2(int i);   // both-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
+void order2();        // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}} \
+                         strict-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
+                         strict-note {{this function declaration without a prototype changes behavior in C2x}}
+
+void order3();        // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}} \
+                         strict-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
+                         strict-note {{this function declaration without a prototype changes behavior in C2x}}
+void order3(int i) {} // both-warning {{this function declaration with a prototype changes behavior in C2x because it is preceded by a function without a prototype}}
+
+// Just because the prototype is variadic doesn't mean we shouldn't warn on the
+// K&R C function definition; this still changes behavior in C2x.
+void test(char*,...); // both-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
+void test(fmt)        // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}} \
+                         strict-note {{this function declaration without a prototype changes behavior in C2x}}
+        char*fmt;
+{
+}
+

clang/test/Sema/warn-missing-prototypes.c

-// RUN: %clang_cc1 -fsyntax-only -Wdocumentation -Wmissing-prototypes -verify %s
-// RUN: %clang_cc1 -fsyntax-only -Wdocumentation -Wmissing-prototypes -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -Wdocumentation -Wmissing-prototypes -Wno-deprecated-non-prototype -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wdocumentation -Wmissing-prototypes -Wno-deprecated-non-prototype -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
 
 int f(); // expected-note{{this declaration is not a prototype; add parameter declarations to make it one}}
 // CHECK-NOT: fix-it:"{{.*}}":{[[@LINE-1]]:{{.*}}-[[@LINE-1]]:{{.*}}}:"{{.*}}"
 
 int f(int x) { return x; } // expected-warning{{no previous prototype for function 'f'}}
 
 static int g(int x) { return x; }
 

clang/test/Sema/warn-strict-prototypes.c

 // RUN: %clang_cc1 -triple i386-pc-unknown -fsyntax-only -Wstrict-prototypes -Wno-implicit-function-declaration -verify %s
 // RUN: %clang_cc1 -triple i386-pc-unknown -fsyntax-only -Wstrict-prototypes -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
 
 // function definition with 0 params, no prototype, no preceding declaration.
-void foo0() {} // expected-warning {{this old-style function definition is not preceded by a prototype}}
+void foo0() {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
 // function declaration with unspecified params
-void foo1(); // expected-warning {{this function declaration is not a prototype}}
+void foo1(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
              // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:11-[[@LINE-1]]:11}:"void"
 // function declaration with 0 params
 void foo2(void);
 
 // function definition with 0 params, no prototype.
-void foo1() {} // expected-warning {{this old-style function definition is not preceded by a prototype}}
+void foo1() {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 // function definition with 0 params, prototype.
 void foo2(void) {}
 
 // function type typedef unspecified params
-typedef void foo3(); // expected-warning {{this function declaration is not a prototype}}
+typedef void foo3(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                      // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:19-[[@LINE-1]]:19}:"void"
 
 // global fp unspecified params
-void (*foo4)(); // expected-warning {{this function declaration is not a prototype}}
+void (*foo4)(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                 // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:14-[[@LINE-1]]:14}:"void"
 
 // struct member fp unspecified params
-struct { void (*foo5)(); } s; // expected-warning {{this function declaration is not a prototype}}
+struct { void (*foo5)(); } s; // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                               // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:23-[[@LINE-1]]:23}:"void"
 
 // param fp unspecified params
-void bar2(void (*foo6)()) { // expected-warning {{this function declaration is not a prototype}}
+void bar2(void (*foo6)()) { // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                             // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:24-[[@LINE-1]]:24}:"void"
   // local fp unspecified params
-  void (*foo7)() = 0; // expected-warning {{this function declaration is not a prototype}}
+  void (*foo7)() = 0; // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                       // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:16-[[@LINE-1]]:16}:"void"
   // array fp unspecified params
-  void (*foo8[2])() = {0}; // expected-warning {{this function declaration is not a prototype}}
+  void (*foo8[2])() = {0}; // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                            // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:19-[[@LINE-1]]:19}:"void"
 }
 
 // function type cast using using an anonymous function declaration
 void bar3(void) {
   // casting function w/out prototype to unspecified params function type
-  (void)(void(*)()) foo1; // expected-warning {{this function declaration is not a prototype}}
+  (void)(void(*)()) foo1; // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                           // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:18-[[@LINE-1]]:18}:"void"
   // .. specified params
   (void)(void(*)(void)) foo1;
 }
 
 // K&R function definition not preceded by full prototype
-int foo9(a, b) // expected-warning {{old-style function definition is not preceded by a prototype}}
+int foo9(a, b) // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
   int a, b;
 {
   return a + b;
 }
 
 // Function declaration with no types
-void foo10(); // expected-warning {{this function declaration is not a prototype}}
-              // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:12-[[@LINE-1]]:12}:"void"
+void foo10(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
+                 expected-note {{this function declaration without a prototype changes behavior in C2x}}
+              // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"void"
 // K&R function definition with incomplete param list declared
-void foo10(p, p2) void *p; {} // expected-warning {{old-style function definition is not preceded by a prototype}}
+void foo10(p, p2) void *p; {} // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
 
-// K&R function definition with previous prototype declared is not diagnosed.
-void foo11(int p, int p2);
-void foo11(p, p2) int p; int p2; {}
+void foo11(int p, int p2);          // expected-warning {{this function declaration with a prototype changes behavior in C2x because it is followed by a function without a prototype}}
+void foo11(p, p2) int p; int p2; {} // expected-note {{this function declaration without a prototype changes behavior in C2x}}
 
 // PR31020
-void __attribute__((cdecl)) foo12(d) // expected-warning {{this old-style function definition is not preceded by a prototype}}
+void __attribute__((cdecl)) foo12(d) // expected-warning {{this function declaration without a prototype is deprecated in all versions of C and changes behavior in C2x}}
   short d;
 {}
 
 // No warnings for variadic functions. Overloadable attribute is required
 // to avoid err_ellipsis_first_param error.
 // rdar://problem/33251668
 void foo13(...) __attribute__((overloadable));
 void foo13(...) __attribute__((overloadable)) {}
 
 // We should not generate a strict-prototype warning for an implicit
 // declaration.  Leave that up to the implicit-function-declaration warning.
 void foo14(void) {
   foo14_call(); // no-warning
 }

clang/test/Sema/warn-strict-prototypes.m

 // RUN: %clang_cc1 -fsyntax-only -Wstrict-prototypes -verify -fblocks %s
 
 @interface Foo
 
-@property (nonatomic, copy) void (^noProtoBlock)(); // expected-warning {{this block declaration is not a prototype}}
+@property (nonatomic, copy) void (^noProtoBlock)(); // expected-warning {{a block declaration without a prototype is deprecated}}
 @property (nonatomic, copy) void (^block)(void); // no warning
 
-- doStuff:(void (^)()) completionHandler; // expected-warning {{this block declaration is not a prototype}}
+- doStuff:(void (^)()) completionHandler; // expected-warning {{a block declaration without a prototype is deprecated}}
 - doOtherStuff:(void (^)(void)) completionHandler; // no warning
 
 @end
 
-void foo() { // expected-warning {{this old-style function definition is not preceded by a prototype}}
-  void (^block)() = // expected-warning {{this block declaration is not a prototype}}
+void foo() { // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+  void (^block)() = // expected-warning {{a block declaration without a prototype is deprecated}}
                     ^void(int arg) { // no warning
   };
-  void (^block2)(void) = ^void() { // no warning
+  // FIXME: this should say "a block declaration" instead, but block literal
+  // expressions do not track their full declarator information, so we don't
+  // know it's a block when diagnosing.
+  void (^block2)(void) = ^void() { // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
   };
   void (^block3)(void) = ^ { // no warning
   };
 }
 
-void (*(^(*(^block4)()) // expected-warning {{this block declaration is not a prototype}}
-     ()) // expected-warning {{this function declaration is not a prototype}}
-     ()) // expected-warning {{this block declaration is not a prototype}}
-     (); // expected-warning {{this function declaration is not a prototype}}
+void (*(^(*(^block4)()) // expected-warning {{a block declaration without a prototype is deprecated}}
+     ()) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+     ()) // expected-warning {{a block declaration without a prototype is deprecated}}
+     (); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}

clang/test/SemaOpenCL/address-spaces.cl

-// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
-// RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only
-// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=+__opencl_c_generic_address_space -verify -pedantic -fsyntax-only
+// RUN: %clang_cc1 %s -verify=expected,c -pedantic -fsyntax-only
+// RUN: %clang_cc1 %s -cl-std=CL2.0 -verify=expected,c -pedantic -fsyntax-only
+// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=+__opencl_c_generic_address_space -verify=expected,c -pedantic -fsyntax-only
 // RUN: %clang_cc1 %s -cl-std=clc++1.0 -verify -pedantic -fsyntax-only
 // RUN: %clang_cc1 %s -cl-std=clc++2021 -cl-ext=+__opencl_c_generic_address_space -verify -pedantic -fsyntax-only
 
 __constant int ci = 1;
 
 // __constant ints are allowed in constant expressions.
 enum use_ci_in_enum { enumerator = ci };
 typedef int use_ci_in_array_bound[ci];
void func_multiple_addr(void) {
   __local private_int_t var3;   // expected-error {{multiple address spaces specified for type}}
   __local private_int_t *var4;  // expected-error {{multiple address spaces specified for type}}
   __private private_int_t var5; // expected-warning {{multiple identical address spaces specified for type}}
   __private private_int_t *var6;// expected-warning {{multiple identical address spaces specified for type}}
 }
 
 void func_with_array_param(const unsigned data[16]);
 
-__kernel void k() {
+__kernel void k() { // c-warning {{a function declaration without a prototype is deprecated in all versions of C}}
   unsigned data[16];
   func_with_array_param(data);
 }
 
 void func_multiple_addr2(void) {
   typedef __private int private_int_t;
   __attribute__((opencl_global)) __private int var1;   // expected-error {{multiple address spaces specified for type}} \
                                                        // expected-error {{function scope variable cannot be declared in global address space}}

clang/test/SemaOpenCL/cl20-device-side-enqueue.cl

 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS=
 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS= -cl-ext=-cl_khr_subgroups
 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS="const volatile"
 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS=
 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS="const volatile"
 // RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS=
 // RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS= -cl-ext=-cl_khr_subgroups,-__opencl_c_subgroups
 // RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS="const volatile"
 // RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS=
 // RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS="const volatile"
 
 typedef struct {int a;} ndrange_t;
 // Diagnostic tests for different overloads of enqueue_kernel from Table 6.13.17.1 of OpenCL 2.0 Spec.
-kernel void enqueue_kernel_tests() {
+kernel void enqueue_kernel_tests(void) {
   queue_t default_queue;
   unsigned flags = 0;
   QUALS ndrange_t ndrange;
   clk_event_t evt;
   clk_event_t event_wait_list;
   clk_event_t event_wait_list2[] = {evt, evt};
   void *vptr;
 
#endif
   enqueue_kernel(default_queue, flags, ndrange, 1, &event_wait_list, &evt); // expected-error{{illegal call to enqueue_kernel, incorrect argument types}}
 
   enqueue_kernel(default_queue, flags, ndrange, 1, 1); // expected-error{{illegal call to enqueue_kernel, incorrect argument types}}
 
   enqueue_kernel(default_queue, ndrange, ^{}); // expected-error{{too few arguments to function call, expected at least 4, have 3}}
 }
 
 // Diagnostic tests for get_kernel_work_group_size and allowed block parameter types in dynamic parallelism.
-kernel void work_group_size_tests() {
+kernel void work_group_size_tests(void) {
   void (^const block_A)(void) = ^{
     return;
   };
   void (^const block_B)(int) = ^(int a) {
     return;
   };
   void (^const block_C)(local void *) = ^(local void *a) {
     return;
kernel void work_group_size_tests(void) {
   size = get_kernel_preferred_work_group_size_multiple(block_A, 1); // expected-error{{too many arguments to function call, expected 1, have 2}}
 }
 
 #ifdef cl_khr_subgroups
 #pragma OPENCL EXTENSION cl_khr_subgroups : enable
 kernel void foo(global unsigned int *buf)
 {
   ndrange_t n;
-  buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, ^(){});
+  // FIXME: this should be diagnosed as a block instead of a function, but
+  // block literals don't track the ^ as part of their declarator.
+  buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, ^(){}); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
   buf[0] = get_kernel_max_sub_group_size_for_ndrange(0, ^(){}); // expected-error{{illegal call to 'get_kernel_max_sub_group_size_for_ndrange', expected 'ndrange_t' argument type}}
+                                                                // expected-warning@-1 {{a function declaration without a prototype is deprecated in all versions of C}}
   buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, 1); // expected-error{{illegal call to 'get_kernel_max_sub_group_size_for_ndrange', expected block argument type}}
 }
 
 kernel void bar(global unsigned int *buf)
 {
   __private ndrange_t n;
-  buf[0] = get_kernel_sub_group_count_for_ndrange(n, ^(){});
+  // FIXME: this should be diagnosed as a block instead of a function, but
+  // block literals don't track the ^ as part of their declarator.
+  buf[0] = get_kernel_sub_group_count_for_ndrange(n, ^(){}); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
   buf[0] = get_kernel_sub_group_count_for_ndrange(0, ^(){}); // expected-error{{illegal call to 'get_kernel_sub_group_count_for_ndrange', expected 'ndrange_t' argument type}}
+                                                             // expected-warning@-1 {{a function declaration without a prototype is deprecated in all versions of C}}
   buf[0] = get_kernel_sub_group_count_for_ndrange(n, 1); // expected-error{{illegal call to 'get_kernel_sub_group_count_for_ndrange', expected block argument type}}
 }
 
 #pragma OPENCL EXTENSION cl_khr_subgroups : disable
 #else
 kernel void foo1(global unsigned int *buf)
 {
   ndrange_t n;
+  // FIXME: this should be diagnosed as a block instead of a function, but
+  // block literals don't track the ^ as part of their declarator.
   buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, ^(){}); // expected-error {{use of declaration 'get_kernel_max_sub_group_size_for_ndrange' requires cl_khr_subgroups or __opencl_c_subgroups support}}
+                                                                // expected-warning@-1 {{a function declaration without a prototype is deprecated in all versions of C}}
 }
 
 kernel void bar1(global unsigned int *buf)
 {
   ndrange_t n;
+  // FIXME: this should be diagnosed as a block instead of a function, but
+  // block literals don't track the ^ as part of their declarator.
   buf[0] = get_kernel_sub_group_count_for_ndrange(n, ^(){}); // expected-error {{use of declaration 'get_kernel_sub_group_count_for_ndrange' requires cl_khr_subgroups or __opencl_c_subgroups support}}
+                                                             // expected-warning@-1 {{a function declaration without a prototype is deprecated in all versions of C}}
 }
 #endif // ifdef cl_khr_subgroups

clang/test/SemaOpenCL/func.cl

 
 //Function pointer
 void foo(void*);
 #ifdef FUNCPTREXT
 //expected-note@-2{{passing argument to parameter here}}
 #endif
 
 // Expect no diagnostics for an empty parameter list.
-void bar();
+void bar(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
-void bar()
+void bar() // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 {
   // declaring a function pointer is an error
   void (*fptr)(int);
 #ifndef FUNCPTREXT
   // expected-error@-2 {{pointers to functions are not allowed}}
 #endif
 
   // taking the address of a function is an error