
GCC 5.1 released - fs111
https://gcc.gnu.org/gcc-5/changes.html
======
ploxiln
I won't be able to use them in portable code anytime soon, but the new feature
here that most interests me is __builtin_add_overflow, __builtin_sub_overflow
and __builtin_mul_overflow

"These builtins have two integral arguments (which don't need to have the same
type), the arguments are extended to infinite precision signed type, +, - or *
is performed on those, and the result is stored in an integer variable pointed
to by the last argument. If the stored value is equal to the infinite
precision result, the built-in functions return false, otherwise true. The
type of the integer variable that will hold the result can be different from
the types of the first two arguments."

Handling all possible integer overflow with plain C is annoyingly tricky and
for some critical paths in-efficient. These built-ins can often do a
conditional jump based on the overflow bit in the flags register.

~~~
Someone
That may be sooner than you think, depending on what you mean by portable. I
think these functions originated as non-generic versions in clang
([http://clang.llvm.org/docs/LanguageExtensions.html#builtin-f...](http://clang.llvm.org/docs/LanguageExtensions.html#builtin-
functions)). gcc copied them and now added generic variants. I think it is
likely that clang will now copy gcc and add the generic variants.

Edit: here is the request for gcc to copy clang:
[https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59708](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59708)
(nice discussion about the need to have builtins for overflow detection)

And here is a request for clang to copy gcc's generic versions:
[https://llvm.org/bugs/show_bug.cgi?id=21716](https://llvm.org/bugs/show_bug.cgi?id=21716)

~~~
madez
This is a good example of how competition is contribution.

------
halosghost
Some of these are terrific changes! E.g., OpenMP 4.0 and Cilk Plus support,
wew! I also love that ``gcc`` now defaults to ``-std=gnu11`` instead of
``-std=gnu89``; what a huge step forward! But, there were a couple of things
in here that I was hoping to see but did not find (namely, it seems gcc still
does not have ``-Weverything``).

While I am glad to see gcc making progress, I feel bound to clang until gcc's
warning/error reporting can get up-to-speed.

~~~
BinaryIdiot
> namely, it seems gcc still does not have ``-Weverything``

I would love to have a -Weverything; as a fairly rusty C++ dev I originally
thought -Wall was supposed to have, you know, all but was pretty surprised to
learn it didn't actually contain all. It would be great if they deprecated
-Wall and made it so -Weverything always did all warnings (including any newly
introduced warnings).

~~~
jeorgun
Clang's -Weverything isn't really as useful as it sounds; since it includes
fairly-to-completely useless warnings like -Wc++98-compat, -Wpadded, or
-Wweak-vtables, you'll end up spending so much time playing warning whack-a-
mole that you might as well have not enabled the thing in the first place. At
least that's been my experience.

~~~
halosghost
I completely disagree. It's true that some of the warnings it enables aren't
terribly useful, but being able to enable all warnings is very helpful instead
of having to manually list ~40 flags. Additionally, -Wpadded and the like are
actually helpful for optimizations.

Plus, writing code (in C, I cannot speak for Cxx) which results in no warning
output from `-Weverything` is actually not that difficult to do, and generally
the result is that you've written more robust code in the process. A lot of
projects are now trying to move to compile with `-Weverything` and not disable
any warnings, and I personally think it's a great move.

~~~
jeorgun
For C, I'd agree that it's useful. The flags I listed have issues specifically
for C++. -Wc++98-compat, on a C++11 or C++14 project, is about as helpful as
you'd expect. -Wpadded is triggered pretty reliably by subclassess. And so
forth.

Of course it is possible to specifically disable useless warnings, but in my
experience it's just as easy to add a reasonable selection of flags (say,
-Wall -Wextra -Wold-style-cast -Wconversion -Wsign-conversion) than to start
with -Weverything and work backwards. Still, it has been some time since I've
tried using it; maybe I ought to give it another chance.

~~~
cpeterso
Here's a detailed explanation of -Weverything from a clang developer. He says
-Weverything is intended for clang developers' own testing. He recommends
using -Wall -Wextra plus any individual warnings you may want.

[http://programmers.stackexchange.com/a/124574](http://programmers.stackexchange.com/a/124574)

clang does not document its warning flags like gcc does, but a long (but now
incomplete) list is available here:

[http://fuckingclangwarnings.com/](http://fuckingclangwarnings.com/)

------
jcoffland
It seems like the GCC guys have really kicked it up a notch. I think LLVM has
inspired them to move it or loose it. At this rate they can expect to still be
a relevent compiler system for a very long time.

------
przemoc
Jakub Jelinek's announcement on ML:

[https://gcc.gnu.org/ml/gcc/2015-04/msg00287.html](https://gcc.gnu.org/ml/gcc/2015-04/msg00287.html)

And the same one for gmane lovers (like me):

[http://thread.gmane.org/gmane.comp.gcc.devel/139625](http://thread.gmane.org/gmane.comp.gcc.devel/139625)

------
wnissen
Whoa, this is the first time the ABI has been deliberately broken since, what,
3.4? I see it's due to the small string optimization and a std::list that
tracks its size, which will be nice but I don't know it's worth breaking
compatibility for that by default. Still, it's an impressive string of
compatibility, and I applaud the maintainers. I've successfully built 4.9.0
against 4.1.2 with exceptions, etc. and it Just Works.

~~~
the_why_of_y
The changes were necessary so that libstdc++ conforms to the C++11 standard,
which introduced new requirements on std::list and std::string.

And this time they managed to do it without a SONAME bump, which is nice.

------
ehmmm
It is so close to full C11 support.

I think just threads.h are missing now.

~~~
bstamour
I haven't really heard much buzz about C11 since its release. I don't mean to
sound snarky (I'm really curious): does anyone really use C11 at all?

~~~
huu
I use C++11 and it's awesome. It's expressive like python but still maintains
strict type safety. I built a (still young) curl wrapper using C++11:
[https://github.com/whoshuu/cpr](https://github.com/whoshuu/cpr)

Edit: Misread the parent posts and thought they were referring to C++11. Today
I learned C11 is a separate standard.

~~~
Devid2014
Nice looking project but unfortunately it is GPL. Unlike Curl it self because
it uses MIT like license.

~~~
loup-vaillant
Too bad proprietary projects can't link against it. A loss for us all.

Seriously? GPL stuff can be used with any internal stuff, and almost any Free
stuff. Isn't that enough? Where is the loss exactly?

 _Edit: okay, that wasn 't the author's intention, and the consistency
argument is a good one (least astonishment and all that). Still, the general
argument holds._

------
mattgodbolt
Took a little longer than I'd hoped but GCC explorer now has support for GCC
5.1 : [https://gcc.godbolt.org](https://gcc.godbolt.org)

It doesn't support LTO as yet due to the way it works so some of the juicier
optimisations aren't visible. But you still get a chance to play about with
the quality of the code generator.

------
JoeAltmaier
I'm troubled that 'write-only variables are ... optimized out'. That means, no
more embedded trace buffers in memory dumps? I've used that for decades to
debug intermittent problems. Maybe there's some way to tag necessary write-
only variables...

~~~
JoachimSchipper
volatile works, asm works, and it's usually not hard to trick the optimizer.

~~~
TheLoneWolfling
It's becoming harder to trick the optimizer all the time.

I mean, the goal of an optimizer is literally not to be able to be tricked
into doing work it doesn't have to.

~~~
JoachimSchipper
Yes; e.g. [http://cvsweb.openbsd.org/cgi-
bin/cvsweb/src/lib/libc/string...](http://cvsweb.openbsd.org/cgi-
bin/cvsweb/src/lib/libc/string/explicit_bzero.c) demonstrates that rather
well. Still, it is and will remain possible - and for the intended use, that's
probably good enough. (It's not write - and - forget code where tricking the
optimizer is security-critical.)

~~~
TheLoneWolfling
If you're having to trick the optimizer, you're doing something wrong.

If the language is such that there are things in the language that inherently
require tricking the optimizer, the language is doing it wrong.

------
stefantalpalaru
Any news about escape analysis for gccgo?

