It doesn't rule out gcc, but what it does do is make people compile at less-than-maximal levels of optimization, just to avoid being bitten by their "LOL that's UB we'll do whatever we want" attitude.
At a time when safer code is called for, gcc has elected to compete by producing faster code, egged on by benchmark fanatics rather than actual customers. Good job, guys... we'll all be forced to write Ada by the time you're done. But hey, those elided while(1) loops will really run fast.
Typical alarmism. There is really no need to resort to defaulting to worse optimization levels due to this kind of fearmongering. I mean, bugs happen, this is why we have processes to write better software and testing to catch these bugs. It's not like we are talking about GCC being buggy, we are talking about
gcc being unhelpful detecting some bugs caused by programming errors, a huge difference to begin with. And
usually, gcc is quite helpful, but there have been a few cases where they have gone too far and being assholes about it, but
still the right thing to do is to fix your broken code and go on with your life. And of course report bugs if you find actual compiler bugs but that is quite rare.
But really,
usually the story is some horrible randomly cobbled together untested, unmaintained spaghetti codebase which can fail on any compiler and any optimization setting, and then instead of fixing it, it's easier to throw a temper tantrum at compiler optimizations, as compiling at -O0 seemingly fixes it, and this tantrum is easily fueled by some googling revealing blog posts with critique against GCC, some deserved, but this is all unnecessary rationalization, you should be spending the time fixing the code and not explaining.
Plus, of course the good old tale about C supposedly being a "portable assembler" still lives strong, regardless of such idea being completely dismissed by the C abstract machine concept already in the 1989 standard.
C is like any other high-level language, for example C will optimize away a non-volatile-qualified variable which holds a constant value like any other sensible modern language, deal with it, any other compiler will do it too except some super archaic one.
I have used GCC* for various projects for years and have
never needed to decrease optimization level to solve a bug, and I'm not a particularly excellent programmer. I don't even use the "decrease the optimization just to see if bug goes away" faultfinding strategy, I think it's a horrible strategy because it never leads to any particular point in code. Just good old debugging strategies, think, validate, log, follow the leads, and you will find any bug. And if necessary, rewrite and simplify.
*) because I have been too lazy to give clang a try, I probably should