GCC vs Clang: Meaning of "-pedantic-errors"

Question

I'm using Clang v3.7.0 with Mingw-w64 5.1.0 and GCC 5.1.0, all 64-bit, on Windows 10. My goal is to use a set of Clang and GCC options that will give me the best chance of detecting potential C89 and C++98 language standards portability issues across many different compilers. For example, for C I have been using the following GCC command line with pretty good success:

gcc -c -x c -std=c89 -pedantic-errors -Wall -Wextra -Wno-comment -Wno-parentheses -Wno-format-zero-length test.c

However, I recently tried it with Clang and got a different result. Here is my sample test code:

int main(void)
{
    int length = (int)strlen("Hello");
    return 0;
}

With Clang I get the following error, whereas with GCC I get the same basic thing, but it flags it as a warning instead:

test.c:3:22: error: implicitly declaring library function 'strlen'
with type 'unsigned long long (const char *)'
    int length = (int)strlen("Hello");

If I remove the -pedantic-errors option, or just change it to -pedantic, Clang then only flags it as a warning, which is what I actually want. However, according to the GCC documentation the -pedantic-errors option causes warnings that are considered language extensions to be flagged as errors, but not using a prototype for a function is not an extension in C89. So, I have three basic questions:

1. Has Clang changed the meaning of -pedantic-errors from the meaning used by GCC, or am I misinterpreting something?

2. What is the best set of options that will enforce adherence to the selected standard and will issue errors for all non-conforming code?

3. If I continue to use -pedantic-errors with Clang is there a way to get it to issue a warning instead of an error in specific cases? In another posting on this site an answer was given that said to use the following, where foo is the error:

   -Wno-error=foo
   

If that is a correct approach, what do I actually use in place of foo for an error like I'm getting since there is no actual error number indicated? I can't believe it actually wants all of the following:

-Wno-error=implicitly declaring library function 'strlen'
with type 'unsigned long long (const char *)'

Answer 1

Your code is invalid, and the behavior is undefined, so the compiler can do anything also when compiling. The implicitly declared int strlen(char*) is not compatible with size_t strlen(const char *).

Has Clang changed the meaning of -pedantic-errors from the meaning used by GCC, or am I misinterpreting something?

As I read it, yes. From clang documentation:

-pedantic-errors

    Error on language extensions.

In GCC:

-pedantic

    Issue all the warnings demanded by strict ISO C and ISO C++ [...]

-pedantic-errors

    Give an error whenever the base standard (see -Wpedantic) requires a diagnostic, in some cases where there is undefined behavior at compile-time and in some other cases that do not prevent compilation of programs that are valid according to the standard.

Clang errors on extensions.

GCC errors when standard explicitly requires it and in other "some cases".

This is a different, it is a different set of errors. Standard may not require a diagnostic, but it's still an extension - GCC will be silent, Clang will error.

What is the best set of options that will enforce adherence to the selected standard and will issue errors for all non-conforming code?

The first answer that comes to mind is: "none". Compiler inherently use "implementation-defined behavior" and extension, because they are meant to compile the code in the first place, not meant to not compile non-conforming code. There are cases where the code is conforming, but still the behavior differs between compilers - you can explore such a case here.

Anyway, keep using -pedantic-errors, as it seems to work in detection of non-conforming code. Your code is invalid, the behavior is undefined, so your code is non-conforming, so clang properly detects it. Also use linters and sanitizers to detect other cases of undefined behavior.

If I continue to use -pedantic-errors with Clang is there a way to get it to issue a warning instead of an error in specific cases?

Use -fno-builtin.