[Bug c/110249] __builtin_unreachable helps optimisation at -O1 but not at -O2
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110249 --- Comment #4 from David Brown --- Yes, __builtin_assume_aligned is the best way to write things in this particular case (and optimises fine for -O1 and -O2). It is also clearer in the source code (IMHO), as it shows the programmer's intention better. I am just a little concerned that optimisation hints provided by the programmer via __builtin_unreachable are getting lost at -O2. When the compiler knows that something cannot happen - whether by __builtin_unreachable or by other code analysis - it can often use that information to generate more efficient code. If that information can be used for better code at -O1, but is lost at -O2, then something is wrong in the way that information is collected or passed on inside the compiler. Any case of -O1 generating more efficient code than -O2 is a sign of a problem or limitation. So I am not particularly bothered about this one piece of code - I am reporting the issue because it might be an indication of a wider problem.
[Bug c/110249] __builtin_unreachable helps optimisation at -O1 but not at -O2
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110249 --- Comment #3 from Richard Biener --- We could pattern-match this to p = __builtin_assume_aligned (p, 8); which is btw the better way to write this.
[Bug c/110249] __builtin_unreachable helps optimisation at -O1 but not at -O2
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110249
--- Comment #2 from David Brown ---
My apologies - it does not optimise the code to a single aligned load at -O1
(at least, not with the combinations I have now tried). The code was
originally C++, with a reference, which /does/ exhibit this behaviour of having
better code at -O1 than -O2. I had translated the reference to a pointer to
get more generic code that is valid as C and C++, but I don't see the same
effect with the pointer.
For a reference, the issue is as I first described:
#include
#include
uint64_t read64r(const uint64_t ) {
if ((uint64_t) % 8 ) {
__builtin_unreachable();
}
uint64_t value;
memcpy( , , sizeof(uint64_t) );
return value;
}
I tested with 64-bit RISC-V and 32-bit ARM using trunk (gcc 13.1, I think) on
godbolt.org. The only relevant flag was the optimisation level.
[Bug c/110249] __builtin_unreachable helps optimisation at -O1 but not at -O2
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110249 Alexander Monakov changed: What|Removed |Added CC||amonakov at gcc dot gnu.org --- Comment #1 from Alexander Monakov --- Please show 'gcc -v' for the case when you get one aligned load at -O1.
