W/ Clang, compile C/C++ testcases with -Wno-unknown-warning-option

Message ID 4a87b8c6-a71c-cb54-8e23-7388c7128c2e@redhat.com
State New
Headers show
Series
  • W/ Clang, compile C/C++ testcases with -Wno-unknown-warning-option
Related show

Commit Message

Lancelot SIX via Gdb-patches June 17, 2020, 7:53 p.m.
On 6/17/20 6:29 PM, Gary Benson via Gdb-patches wrote:
> Pedro Alves wrote:


>> In general, the problematic sequence is something like this:

>>

>> #1 - A testcase compiles successfully with clang version X.

>> #2 - clang version "X + 1" adds a new warning, enabled by default,

>>      which breaks the test.

>> #3 - We add -Wno-newwarning, fixing the testcase with clang "X + 1"

>> #4 - Now building the test with clang version X no longer works,

>>      due to "unknown warning option".

>>

>> Making gcc_compile always add -Wno-unknown-warning-option to the

>> build flags fixes this problem for good.  At least with clang.

> 

> Right.

> 

> First, I'm assuming you mean gdb_compile, not gcc_compile?


Yes.

> 

> Second, it's not clear whether you mean to add it always, or just

> if the compiler is clang?


For Clang.

> 

> Third, is this something you could easily do?  Because I've spent

> nearly an hour on this already, gdb_compile is nearly 250 lines of

> special cases and I'm no closer to figuring out where I wouldn't

> break something.


Sure.  Like this.

I tried adding -Wno-foo to a testcase and checked that without
the patch it failed due to the "unknown option" warning, and
passed with the patch.

From 79f1cfddeea957a778c856c879a386901a96609b Mon Sep 17 00:00:00 2001
From: Pedro Alves <palves@redhat.com>

Date: Wed, 17 Jun 2020 19:29:37 +0100
Subject: [PATCH] W/ Clang, compile C/C++ testcases with
 -Wno-unknown-warning-option

Some C/C++ testcases unconditionally pass -Wno-foo as additional
options to disable some warning.  That is OK with GCC, because GCC
accepts -Wno-foo silently even if it doesn't support -Wfoo.  This is a
feature which allows disabling warnings with newer compilers without
breaking builds with older compilers.  Clang however warns about
unknown -Wno-foo by default, unless you pass
-Wno-unknown-warning-option as well:

 $ gcc -Wno-foo test.c
 * nothing, compiles successfuly *

 $ clang -Wno-foo test.c
 warning: unknown warning option '-Wno-foo [-Wunknown-warning-option]

This commit adds -Wunknown-warning-option centrally in gdb_compile, so
that individual testcases don't have to worry about breaking older
Clangs.

IOW, this avoids this problematic scenario:

#1 - A testcase compiles successfully with Clang version X.
#2 - Clang version "X + 1" adds a new warning, enabled by default,
     which breaks the test.
#3 - We add -Wno-newwarning to the testcase, fixing the testcase with
     clang "X + 1".
#4 - Now building the test with Clang version X no longer works, due
     to "unknown warning option".

gdb/testsuite/ChangeLog:
yyyy-mm-dd  Pedro Alves  <palves@redhat.com>

	* lib/gdb.exp (gdb_compile): Update intro comment.  If C/C++ with
	Clang, add "-Wno-unknown-warning-option" to the options.
---
 gdb/testsuite/lib/gdb.exp | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)


base-commit: 669203174311c5be76744a879563c697cd479853
-- 
2.14.5

Comments

Lancelot SIX via Gdb-patches June 18, 2020, 4:18 p.m. | #1
Pedro Alves wrote:
> From 79f1cfddeea957a778c856c879a386901a96609b Mon Sep 17 00:00:00 2001

> From: Pedro Alves <palves@redhat.com>

> Date: Wed, 17 Jun 2020 19:29:37 +0100

> Subject: [PATCH] W/ Clang, compile C/C++ testcases with

>  -Wno-unknown-warning-option

> 

> Some C/C++ testcases unconditionally pass -Wno-foo as additional

> options to disable some warning.  That is OK with GCC, because GCC

> accepts -Wno-foo silently even if it doesn't support -Wfoo.  This is a

> feature which allows disabling warnings with newer compilers without

> breaking builds with older compilers.  Clang however warns about

> unknown -Wno-foo by default, unless you pass

> -Wno-unknown-warning-option as well:

> 

>  $ gcc -Wno-foo test.c

>  * nothing, compiles successfuly *

> 

>  $ clang -Wno-foo test.c

>  warning: unknown warning option '-Wno-foo [-Wunknown-warning-option]

> 

> This commit adds -Wunknown-warning-option centrally in gdb_compile, so

> that individual testcases don't have to worry about breaking older

> Clangs.

> 

> IOW, this avoids this problematic scenario:

> 

> #1 - A testcase compiles successfully with Clang version X.

> #2 - Clang version "X + 1" adds a new warning, enabled by default,

>      which breaks the test.

> #3 - We add -Wno-newwarning to the testcase, fixing the testcase with

>      clang "X + 1".

> #4 - Now building the test with Clang version X no longer works, due

>      to "unknown warning option".

> 

> gdb/testsuite/ChangeLog:

> yyyy-mm-dd  Pedro Alves  <palves@redhat.com>

> 

> 	* lib/gdb.exp (gdb_compile): Update intro comment.  If C/C++ with

> 	Clang, add "-Wno-unknown-warning-option" to the options.

> ---

>  gdb/testsuite/lib/gdb.exp | 19 ++++++++++++++++++-

>  1 file changed, 18 insertions(+), 1 deletion(-)

> 

> diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp

> index f502eb157d8..bbc940a4512 100644

> --- a/gdb/testsuite/lib/gdb.exp

> +++ b/gdb/testsuite/lib/gdb.exp

> @@ -3826,7 +3826,8 @@ set gdb_saved_set_unbuffered_mode_obj ""

>  #   - ldflags=flag: Add FLAG to the linker flags.

>  #   - incdir=path: Add PATH to the searched include directories.

>  #   - libdir=path: Add PATH to the linker searched directories.

> -#   - ada, c++, f77: Compile the file as Ada, C++ or Fortran.

> +#   - ada, c++, f77, f90, rust: Compile the file as Ada, C++,

> +#     Fortran 77, Fortran 90 or Rust.

>  #   - debug: Build with debug information.

>  #   - optimize: Build with optimization.

>  

> @@ -3850,6 +3851,22 @@ proc gdb_compile {source dest type options} {

>  	set new_options [universal_compile_options]

>      }

>  

> +    # Some C/C++ testcases unconditionally pass -Wno-foo as additional

> +    # options to disable some warning.  That is OK with GCC, because

> +    # by design, GCC accepts any -Wno-foo option, even if it doesn't

> +    # support -Wfoo.  Clang however warns about unknown -Wno-foo by

> +    # default, unless you pass -Wno-unknown-warning-option as well.

> +    # We do that here, so that individual testcases don't have to

> +    # worry about it.

> +    if {[lsearch -exact $options getting_compiler_info] == -1

> +	&& [lsearch -exact $options rust] == -1

> +	&& [lsearch -exact $options ada] == -1

> +	&& [lsearch -exact $options f77] == -1

> +	&& [lsearch -exact $options f90] == -1

> +	&& [test_compiler_info "clang-*"]} {

> +	lappend new_options "additional_flags=-Wno-unknown-warning-option"

> +    }

> +

>      # Place (and look for) Fortran `.mod` files in the output

>      # directory for this specific test.

>      if {[lsearch -exact $options f77] != -1 \

> 

> base-commit: 669203174311c5be76744a879563c697cd479853

> -- 

> 2.14.5


Oh, thanks, that looks great.  Could you commit it please?

Cheers,
Gary

-- 
Gary Benson - he / him / his
Principal Software Engineer, Red Hat
Lancelot SIX via Gdb-patches June 24, 2020, 10:26 p.m. | #2
On 6/18/20 5:18 PM, Gary Benson via Gdb-patches wrote:
> Pedro Alves wrote:

>> From 79f1cfddeea957a778c856c879a386901a96609b Mon Sep 17 00:00:00 2001

>> From: Pedro Alves <palves@redhat.com>

>> Date: Wed, 17 Jun 2020 19:29:37 +0100

>> Subject: [PATCH] W/ Clang, compile C/C++ testcases with

>>  -Wno-unknown-warning-option

>>

>> Some C/C++ testcases unconditionally pass -Wno-foo as additional

>> options to disable some warning.  That is OK with GCC, because GCC

>> accepts -Wno-foo silently even if it doesn't support -Wfoo.  This is a

>> feature which allows disabling warnings with newer compilers without

>> breaking builds with older compilers.  Clang however warns about

>> unknown -Wno-foo by default, unless you pass

>> -Wno-unknown-warning-option as well:

>>

>>  $ gcc -Wno-foo test.c

>>  * nothing, compiles successfuly *

>>

>>  $ clang -Wno-foo test.c

>>  warning: unknown warning option '-Wno-foo [-Wunknown-warning-option]

>>

>> This commit adds -Wunknown-warning-option centrally in gdb_compile, so

>> that individual testcases don't have to worry about breaking older

>> Clangs.

>>

>> IOW, this avoids this problematic scenario:

>>

>> #1 - A testcase compiles successfully with Clang version X.

>> #2 - Clang version "X + 1" adds a new warning, enabled by default,

>>      which breaks the test.

>> #3 - We add -Wno-newwarning to the testcase, fixing the testcase with

>>      clang "X + 1".

>> #4 - Now building the test with Clang version X no longer works, due

>>      to "unknown warning option".

>>

>> gdb/testsuite/ChangeLog:

>> yyyy-mm-dd  Pedro Alves  <palves@redhat.com>

>>

>> 	* lib/gdb.exp (gdb_compile): Update intro comment.  If C/C++ with

>> 	Clang, add "-Wno-unknown-warning-option" to the options.

>> ---

>>  gdb/testsuite/lib/gdb.exp | 19 ++++++++++++++++++-

>>  1 file changed, 18 insertions(+), 1 deletion(-)

>>

>> diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp

>> index f502eb157d8..bbc940a4512 100644

>> --- a/gdb/testsuite/lib/gdb.exp

>> +++ b/gdb/testsuite/lib/gdb.exp

>> @@ -3826,7 +3826,8 @@ set gdb_saved_set_unbuffered_mode_obj ""

>>  #   - ldflags=flag: Add FLAG to the linker flags.

>>  #   - incdir=path: Add PATH to the searched include directories.

>>  #   - libdir=path: Add PATH to the linker searched directories.

>> -#   - ada, c++, f77: Compile the file as Ada, C++ or Fortran.

>> +#   - ada, c++, f77, f90, rust: Compile the file as Ada, C++,

>> +#     Fortran 77, Fortran 90 or Rust.

>>  #   - debug: Build with debug information.

>>  #   - optimize: Build with optimization.

>>  

>> @@ -3850,6 +3851,22 @@ proc gdb_compile {source dest type options} {

>>  	set new_options [universal_compile_options]

>>      }

>>  

>> +    # Some C/C++ testcases unconditionally pass -Wno-foo as additional

>> +    # options to disable some warning.  That is OK with GCC, because

>> +    # by design, GCC accepts any -Wno-foo option, even if it doesn't

>> +    # support -Wfoo.  Clang however warns about unknown -Wno-foo by

>> +    # default, unless you pass -Wno-unknown-warning-option as well.

>> +    # We do that here, so that individual testcases don't have to

>> +    # worry about it.

>> +    if {[lsearch -exact $options getting_compiler_info] == -1

>> +	&& [lsearch -exact $options rust] == -1

>> +	&& [lsearch -exact $options ada] == -1

>> +	&& [lsearch -exact $options f77] == -1

>> +	&& [lsearch -exact $options f90] == -1

>> +	&& [test_compiler_info "clang-*"]} {

>> +	lappend new_options "additional_flags=-Wno-unknown-warning-option"

>> +    }

>> +

>>      # Place (and look for) Fortran `.mod` files in the output

>>      # directory for this specific test.

>>      if {[lsearch -exact $options f77] != -1 \

>>

>> base-commit: 669203174311c5be76744a879563c697cd479853

>> -- 

>> 2.14.5

> 

> Oh, thanks, that looks great.  Could you commit it please?


I've pushed this now, with just a tweak to also list "go".

From 331733cd4e2f2fe76c0b7b6fdd81e54724572354 Mon Sep 17 00:00:00 2001
From: Pedro Alves <palves@redhat.com>

Date: Wed, 24 Jun 2020 23:18:19 +0100
Subject: [PATCH] W/ Clang, compile C/C++ testcases with
 -Wno-unknown-warning-option

Some C/C++ testcases unconditionally pass -Wno-foo as additional
options to disable some warning.  That is OK with GCC, because GCC
accepts -Wno-foo silently even if it doesn't support -Wfoo.  This is a
feature which allows disabling warnings with newer compilers without
breaking builds with older compilers.  Clang however warns about
unknown -Wno-foo by default, unless you pass
-Wno-unknown-warning-option as well:

 $ gcc -Wno-foo test.c
 * nothing, compiles successfuly *

 $ clang -Wno-foo test.c
 warning: unknown warning option '-Wno-foo [-Wunknown-warning-option]

This commit adds -Wunknown-warning-option centrally in gdb_compile, so
that individual testcases don't have to worry about breaking older
Clangs.

IOW, this avoids this problematic scenario:

#1 - A testcase compiles successfully with Clang version X.
#2 - Clang version "X + 1" adds a new warning, enabled by default,
     which breaks the test.
#3 - We add -Wno-newwarning to the testcase, fixing the testcase with
     clang "X + 1".
#4 - Now building the test with Clang version X no longer works, due
     to "unknown warning option".

gdb/testsuite/ChangeLog:
2020-06-24  Pedro Alves  <palves@redhat.com>

	* lib/gdb.exp (gdb_compile): Update intro comment.  If C/C++ with
	Clang, add "-Wno-unknown-warning-option" to the options.
---
 gdb/testsuite/ChangeLog   |  5 +++++
 gdb/testsuite/lib/gdb.exp | 20 +++++++++++++++++++-
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 26284dabb25..6f4d99d3902 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2020-06-24  Pedro Alves  <palves@redhat.com>
+
+	* lib/gdb.exp (gdb_compile): Update intro comment.  If C/C++ with
+	Clang, add "-Wno-unknown-warning-option" to the options.
+
 2020-06-23  Andrew Burgess  <andrew.burgess@embecosm.com>
 
 	* gdb.xml/tdesc-reload.c: New file.
diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp
index 7b243f5fff3..6b4f71be588 100644
--- a/gdb/testsuite/lib/gdb.exp
+++ b/gdb/testsuite/lib/gdb.exp
@@ -3826,7 +3826,8 @@ set gdb_saved_set_unbuffered_mode_obj ""
 #   - ldflags=flag: Add FLAG to the linker flags.
 #   - incdir=path: Add PATH to the searched include directories.
 #   - libdir=path: Add PATH to the linker searched directories.
-#   - ada, c++, f77: Compile the file as Ada, C++ or Fortran.
+#   - ada, c++, f77, f90, go, rust: Compile the file as Ada, C++,
+#     Fortran 77, Fortran 90, Go or Rust.
 #   - debug: Build with debug information.
 #   - optimize: Build with optimization.
 
@@ -3850,6 +3851,23 @@ proc gdb_compile {source dest type options} {
 	set new_options [universal_compile_options]
     }
 
+    # Some C/C++ testcases unconditionally pass -Wno-foo as additional
+    # options to disable some warning.  That is OK with GCC, because
+    # by design, GCC accepts any -Wno-foo option, even if it doesn't
+    # support -Wfoo.  Clang however warns about unknown -Wno-foo by
+    # default, unless you pass -Wno-unknown-warning-option as well.
+    # We do that here, so that individual testcases don't have to
+    # worry about it.
+    if {[lsearch -exact $options getting_compiler_info] == -1
+	&& [lsearch -exact $options rust] == -1
+	&& [lsearch -exact $options ada] == -1
+	&& [lsearch -exact $options f77] == -1
+	&& [lsearch -exact $options f90] == -1
+	&& [lsearch -exact $options go] == -1
+	&& [test_compiler_info "clang-*"]} {
+	lappend new_options "additional_flags=-Wno-unknown-warning-option"
+    }
+
     # Place (and look for) Fortran `.mod` files in the output
     # directory for this specific test.
     if {[lsearch -exact $options f77] != -1 \

base-commit: a8654e7d784980cb4596f685964200fcc1164c78
-- 
2.14.5
Lancelot SIX via Gdb-patches July 2, 2020, 10:02 a.m. | #3
Pedro Alves wrote:
> On 6/18/20 5:18 PM, Gary Benson via Gdb-patches wrote:

> > Pedro Alves wrote:

> > > gdb/testsuite/ChangeLog:

> > > 	* lib/gdb.exp (gdb_compile): Update intro comment.  If C/C++

> > > 	with Clang, add "-Wno-unknown-warning-option" to the options.

> > 

> > Oh, thanks, that looks great.  Could you commit it please?

> 

> I've pushed this now, with just a tweak to also list "go".


Thanks Pedro, I was lost in all the special cases in there!

Cheers,
Gary

-- 
Gary Benson - he / him / his
Principal Software Engineer, Red Hat

Patch

diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp
index f502eb157d8..bbc940a4512 100644
--- a/gdb/testsuite/lib/gdb.exp
+++ b/gdb/testsuite/lib/gdb.exp
@@ -3826,7 +3826,8 @@  set gdb_saved_set_unbuffered_mode_obj ""
 #   - ldflags=flag: Add FLAG to the linker flags.
 #   - incdir=path: Add PATH to the searched include directories.
 #   - libdir=path: Add PATH to the linker searched directories.
-#   - ada, c++, f77: Compile the file as Ada, C++ or Fortran.
+#   - ada, c++, f77, f90, rust: Compile the file as Ada, C++,
+#     Fortran 77, Fortran 90 or Rust.
 #   - debug: Build with debug information.
 #   - optimize: Build with optimization.
 
@@ -3850,6 +3851,22 @@  proc gdb_compile {source dest type options} {
 	set new_options [universal_compile_options]
     }
 
+    # Some C/C++ testcases unconditionally pass -Wno-foo as additional
+    # options to disable some warning.  That is OK with GCC, because
+    # by design, GCC accepts any -Wno-foo option, even if it doesn't
+    # support -Wfoo.  Clang however warns about unknown -Wno-foo by
+    # default, unless you pass -Wno-unknown-warning-option as well.
+    # We do that here, so that individual testcases don't have to
+    # worry about it.
+    if {[lsearch -exact $options getting_compiler_info] == -1
+	&& [lsearch -exact $options rust] == -1
+	&& [lsearch -exact $options ada] == -1
+	&& [lsearch -exact $options f77] == -1
+	&& [lsearch -exact $options f90] == -1
+	&& [test_compiler_info "clang-*"]} {
+	lappend new_options "additional_flags=-Wno-unknown-warning-option"
+    }
+
     # Place (and look for) Fortran `.mod` files in the output
     # directory for this specific test.
     if {[lsearch -exact $options f77] != -1 \