Skip to contentSkip to conversation

configure: Force the C standard to gnu11

PATCH Superseded Thomas Huth 3 participants 13 messages Jan 7, 2019 – Jan 9, 2019

v1 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 configure: Force the C standard to gnu11

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

---
 configure | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
configure +4 -1
index 79375af..07f8105 100755
@@ -107,6 +107,9 @@ update_cxxflags() {
             -Wstrict-prototypes|-Wmissing-prototypes|-Wnested-externs|\
             -Wold-style-declaration|-Wold-style-definition|-Wredundant-decls)
                 ;;
+            -std=gnu11)
+                QEMU_CXXFLAGS=${QEMU_CXXFLAGS:+$QEMU_CXXFLAGS }-std=gnu++11
+                ;;
             *)
                 QEMU_CXXFLAGS=${QEMU_CXXFLAGS:+$QEMU_CXXFLAGS }$arg
                 ;;
@@ -585,7 +588,7 @@ ARFLAGS="${ARFLAGS-rv}"
 # left shift of signed integers is well defined and has the expected
 # 2s-complement style results. (Both clang and gcc agree that it
 # provides these semantics.)
-QEMU_CFLAGS="-fno-strict-aliasing -fno-common -fwrapv $QEMU_CFLAGS"
+QEMU_CFLAGS="-fno-strict-aliasing -fno-common -fwrapv -std=gnu11 $QEMU_CFLAGS"
 QEMU_CFLAGS="-Wall -Wundef -Wwrite-strings -Wmissing-prototypes $QEMU_CFLAGS"
 QEMU_CFLAGS="-Wstrict-prototypes -Wredundant-decls $QEMU_CFLAGS"
 QEMU_CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE $QEMU_CFLAGS"
Signature · 1 line
1.8.3.1
#1 lore raw
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

Quoted 32 lines
---
 configure | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
configure +4 -1
index 79375af..07f8105 100755
@@ -107,6 +107,9 @@ update_cxxflags() {
             -Wstrict-prototypes|-Wmissing-prototypes|-Wnested-externs|\
             -Wold-style-declaration|-Wold-style-definition|-Wredundant-decls)
                 ;;
+            -std=gnu11)
+                QEMU_CXXFLAGS=${QEMU_CXXFLAGS:+$QEMU_CXXFLAGS }-std=gnu++11
+                ;;
             *)
                 QEMU_CXXFLAGS=${QEMU_CXXFLAGS:+$QEMU_CXXFLAGS }$arg
                 ;;
@@ -585,7 +588,7 @@ ARFLAGS="${ARFLAGS-rv}"
 # left shift of signed integers is well defined and has the expected
 # 2s-complement style results. (Both clang and gcc agree that it
 # provides these semantics.)
-QEMU_CFLAGS="-fno-strict-aliasing -fno-common -fwrapv $QEMU_CFLAGS"
+QEMU_CFLAGS="-fno-strict-aliasing -fno-common -fwrapv -std=gnu11 $QEMU_CFLAGS"
 QEMU_CFLAGS="-Wall -Wundef -Wwrite-strings -Wmissing-prototypes $QEMU_CFLAGS"
 QEMU_CFLAGS="-Wstrict-prototypes -Wredundant-decls $QEMU_CFLAGS"
 QEMU_CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE $QEMU_CFLAGS"
Signature · 1 line
1.8.3.1

Regards,
Daniel

Signature · 3 lines
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|
#2 lore raw
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

Thomas

#3 lore raw
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

"3.4 Options Controlling C Dialect

....snip...

     'c11'
     'c1x'
     'iso9899:2011'
          ISO C11, the 2011 revision of the ISO C standard.  Support is
          incomplete and experimental.  The name 'c1x' is deprecated.

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."

Regards,
Daniel

Signature · 3 lines
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|
#4 lore raw
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Thomas

#5 lore raw
Quoted 50 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."
Quoted 5 lines

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Switchinh back could be somewhat painful if we already started using C11 features. And if we don't plan to, then what exactly will -std=gnu11 buy us?

#6 lore raw
Quoted 58 lines · Markus Armbruster
Quoted 50 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."
Quoted 5 lines

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Quoted 3 lines

Switchinh back could be somewhat painful if we already started using C11 features. And if we don't plan to, then what exactly will -std=gnu11 buy us?

With C11, we get safety for the "duplicated typedef" problem that we run into regularly again and again, see e.g.:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Thomas

#7 lore raw
Quoted 59 lines · Thomas Huth
Quoted 58 lines · Markus Armbruster
Quoted 55 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Quoted 8 lines
Quoted 3 lines

Switchinh back could be somewhat painful if we already started using C11 features. And if we don't plan to, then what exactly will -std=gnu11 buy us?

With C11, we get safety for the "duplicated typedef" problem that we run into regularly again and again, see e.g.:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

That's a compilation failure. "Support is experimental" makes me afraid of run time failures.

If we truly want C11, shouldn't we bump minimum required GCC to 4.9?

#8 lore raw
Quoted 68 lines · Markus Armbruster
Quoted 66 lines · Thomas Huth
Quoted 58 lines · Markus Armbruster
Quoted 50 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."
Quoted 5 lines

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Quoted 3 lines

Switchinh back could be somewhat painful if we already started using C11 features. And if we don't plan to, then what exactly will -std=gnu11 buy us?

With C11, we get safety for the "duplicated typedef" problem that we run into regularly again and again, see e.g.:

Quoted 6 lines
Quoted 1 line

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

That's a compilation failure. "Support is experimental" makes me afraid of run time failures.

If we truly want C11, shouldn't we bump minimum required GCC to 4.9?

That's not possible, since we claim to support RHEL7 / CentOS7 that is still using GCC v4.8.

Thomas

#9 lore raw
In reply to Thomas Huth
Quoted 50 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."
Quoted 5 lines

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Our code is already cleanly compiling with gnu99 standard - the problem is merely that we sometimes introduce regressions due to not enforcing that standard level. I don't think the features in gnu11 are compelling enough to justify using something that's declared experimental. As long as we always have a -std=gnu99 flag set, it will avoid the regressions we've seen.

Regards,
Daniel

Signature · 3 lines
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|
#10 lore raw
Quoted 57 lines · Daniel P. Berrangé
Quoted 50 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."
Quoted 5 lines

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Quoted 4 lines

Our code is already cleanly compiling with gnu99 standard - the problem is merely that we sometimes introduce regressions due to not enforcing that standard level. I don't think the features in gnu11 are compelling enough to justify using something that's declared experimental.

What about the duplicated typedef problem? See:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

That one occured with Clang, but I think we've had plenty of these in the past with GCC, too...

Thomas

#11 lore raw
Quoted 62 lines · Thomas Huth
Quoted 57 lines · Daniel P. Berrangé
Quoted 50 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."
Quoted 5 lines

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Quoted 4 lines

Our code is already cleanly compiling with gnu99 standard - the problem is merely that we sometimes introduce regressions due to not enforcing that standard level. I don't think the features in gnu11 are compelling enough to justify using something that's declared experimental.

Quoted 6 lines

What about the duplicated typedef problem? See:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

That one occured with Clang, but I think we've had plenty of these in the past with GCC, too...

IIUC, That's only a problem because we don't pass any -std flag, and so get the compilers default, which may be gnu11. If we explicitly set -std=gnu99, that problem will be reported by patchew, travis and maintainers own build tests, and thus won't get anywhere near git master.

Regards,
Daniel

Signature · 3 lines
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|
#12 lore raw
Quoted 67 lines · Daniel P. Berrangé
Quoted 66 lines · Thomas Huth
Quoted 57 lines · Daniel P. Berrangé
Quoted 50 lines · Thomas Huth
Quoted 40 lines · Daniel P. Berrangé
Quoted 28 lines · Thomas Huth
Quoted 15 lines · Daniel P. Berrangé
Quoted 5 lines · Thomas Huth

Different versions of GCC and Clang use different versions of the C standard. This repeatedly caused problems already, e.g. with duplicated typedefs:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 8 lines

or with for-loop variable initializers:

https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg00237.html

To avoid these problems, we should enforce the C language version to the same level for all compilers. Since our minimum compiler versions are GCC v4.8 and Clang v3.4 now, and both basically support "gnu11" already, this seems to be a good choice.

Quoted 5 lines

In 4.x gnu11 is marked as experimental. I'm not really comfortable
using experimental features - even if its warning free there's a risk it would silently mis-compile something.

gnu99 is ok with 4.x - it is merely "incomplete".

gnu11 has the big advantage that it also fixes the problem with duplicated typedefs that are reported by older versions of Clang.

Are you sure about the experimental character in 4.x? I just looked at
https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Standards.html and it says:

Quoted 8 lines

"A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011."

It does not say anything about "experimental" there. The word "experimental" is only used for the C++ support, but we hardly have C++ code in QEMU -- if you worry about that, I could simply drop the "-std=gnu++11" part from my patch?

I was looking at the "info gcc" docs on RHEL7, gcc-4.8.5-16.el7_4.1.x86_64:

Quoted 8 lines

"3.4 Options Controlling C Dialect

       ....snip...

     'gnu11'
     'gnu1x'
          GNU dialect of ISO C11.  Support is incomplete and
          experimental.  The name 'gnu1x' is deprecated."
Quoted 5 lines

Ok. Looks like the "Support is incomplete and experimental" sentence has been removed with GCC 4.9.0 here. So GCC 4.8 is likely pretty close already. IMHO we could give it a try and enable gnu11 for QEMU with GCC v4.8, too. If we later find problems, we could still switch back to gnu99 instead. Other opinions?

Quoted 4 lines

Our code is already cleanly compiling with gnu99 standard - the problem is merely that we sometimes introduce regressions due to not enforcing that standard level. I don't think the features in gnu11 are compelling enough to justify using something that's declared experimental.

What about the duplicated typedef problem? See:

https://lists.gnu.org/archive/html/qemu-devel/2018-11/msg05829.html

Quoted 7 lines
Quoted 2 lines

That one occured with Clang, but I think we've had plenty of these in the past with GCC, too...

IIUC, That's only a problem because we don't pass any -std flag, and so get the compilers default, which may be gnu11. If we explicitly set -std=gnu99, that problem will be reported by patchew, travis and maintainers own build tests, and thus won't get anywhere near git master.

Ah, right, I just tried it with a newer version of Clang, and indeed it then prints out a warning if some code with a duplicated typedef is compiled with "-std=gnu99" (while it remains silent without that option). So in that case I'm fine with gnu99, too. I'll send a v2 of the patch...

Thomas