Maybe that's the case now, with GCC 8, but historically that hasn't been true.
In the past the effects of using both -g and -O* flags could interact each other because they can both affect how registers are allocated, how call stacks are setup, how functions are inlined, etc. In other words, adding -g by itself made the build non-reproducible.
If that's no longer true in GCC 8 it's great news.
> In other words, adding -g by itself made the build non-reproducible.
In my experience, this is largely not true. However, what is plausible is that before GCC 8, LTO, which, for speed reasons, can split work across multiple threads, was not deterministic, and GCC 8 might have made that better.
AFAIR GCC bootstrap builds by default with "-g -O2". There are 3 stages: 1) use system compiler to compile GCC's source code, 2) use resulting binary to build same source, 3) use binary from 2) to build source one more time. After all stages the binaries from stage 2 and 3 are compared byte for byte if they are identical.
Bootstrap failures are taken very seriously by the GCC developers. So I really doubt that -g and -O* lead to non-deterministic builds.
when i was a full-time hobbyist webdev i was surprised when i learned c compilers don't do whole-program optimization by default but limit themselves by optimizing each translation unit separately (i guess it makes things simpler)
you can get "LTO" in javascript by using a minifier together with something like webpack which can inline modules when it's safe to do so (instead of putting them in functions that are called by the module loader and can't be minified away), so i assumed "real" compilers must do that stuff a lot better with the language being less dynamic
In addition to simplicity it cuts down on compilation time. You can checkout MLTon or Felix to get a feel for whole program optimizing compilers, they can do optimizations that are impossible without LTO and hard to do with.
13 comments
[ 6.1 ms ] story [ 68.2 ms ] threadI've never thought it's possible. Rebuild after the core dump ? Rather than build with debug info and strip it away.
In the past the effects of using both -g and -O* flags could interact each other because they can both affect how registers are allocated, how call stacks are setup, how functions are inlined, etc. In other words, adding -g by itself made the build non-reproducible.
If that's no longer true in GCC 8 it's great news.
In my experience, this is largely not true. However, what is plausible is that before GCC 8, LTO, which, for speed reasons, can split work across multiple threads, was not deterministic, and GCC 8 might have made that better.
Bootstrap failures are taken very seriously by the GCC developers. So I really doubt that -g and -O* lead to non-deterministic builds.
How many __builtin_expects can it remove?
you can get "LTO" in javascript by using a minifier together with something like webpack which can inline modules when it's safe to do so (instead of putting them in functions that are called by the module loader and can't be minified away), so i assumed "real" compilers must do that stuff a lot better with the language being less dynamic
https://github.com/felix-lang/felix
http://felix-documentation-master.readthedocs.io/en/latest/m...
http://mlton.org