LLVM allows you to build one compiler with N backends, whereas GCC basically doesn't. This is very annoying if you want to compile a mixture of code to (say) native object code and shaders.
The first is definitely an issue, how many Nintendo or Sony contributions have landed on upstream?
Or the interesting detail that while standard LLVM bitcode isn't stable, the one used by watchOS is.
Finally the increasing pain that despite the amount of LLVM users topping Linux kernel like usage, clang is now lagging behind C++ compliance.
Which is one of the reasons why GNU C Compiler got renamed as GNU Compiler Collection.
LLVM isn't even anything new as idea.
At very least PL.8, Amsterdam Compiler Toolkit, TrenDRA, MSR Phoenix exist as prior art.
LLVM's design is fundamentally superior in this context - LLVM can "fork" itself inside an LLVM compiler whereas the way GCC is designed basically means all the hooks don't really like having multiple backends connected to the same frontend. It's probably possible, but it's something where GCC's baggage does actually hold it back even if the basic algorithms are exactly the same (and better implemented sometimes, GCC is still king across the whole benchmark suite even if LLVM is increasingly good on a few).
GCC forks, I am aware are nothing new, but the future of programming is not multiple monolithic compilers but rather (say) C++ (or D, e.g. DCompute would be a real hack if implemented on GCC) with shader and WASM bytecode output as part of one compiler.
GCC can and does do the stuff above but it's just a bit hacky and "please scroll through our mailing list" whereas LLVM is much more welcoming and is a proper library to be consumed.
I can enjoy most of C++20 on GCC, whereas good luck waiting for clang to reach parity.
GCC has more frontends and backends available in total than LLVM has yet to achieve, despite being "better".
One of the reasons for Rust-GCC existence is exactly the lack of support for the backends that Linux kernel doesn't want to compromise only to allow Rust into the kernel.
I am a GCC fanboy too, but just be realistic.
Also GCC really needs a kick up the arse when it comes to onboarding new contributors and CI etc. They don't need to go full webscale but I think there's a real risk that GCC ends up being maintained by an increasingly small group of people who eventually just die/retire-off.
The way GCC is tested is quite dumb too, things are pulled but then weeks later someone finds out it failed on such and such a a target because they happened to run the testsuite. It's not terrible but I can't imagine it encourages new contributors.
GCC is doing quite alright, looking at upstream contributions for C++, Fortran and Ada compliance.
LLVM on the other hand, I guess those lechers are quite happy not having to upstream anything.
Apple’s bitcode submission tooling relies on bitcode being forward upgradable, and properties of the ABI to allow it to be retargeted to different SoCs.