clang was designed to do that from the start, and for me this has lead to greatly improved C++ tools.
A friend of mine is a long-time kibitzer of C compilers, and his occasional remarks about the state of the world wholly harmonize with this - GCC was not good for interop, and the contributing process has a higher bar than others.
[1] http://www.imore.com/debug-48-melton-ganatra-episode-ii-unde...
Apple wanted to integrate the compiler more deeply into their IDE, Xcode. GCC didn't allow that without making Xcode GPL too - which was out of the question. Apple has no problems contributing changes back to GCC or clang -- but there is no way they will make XCode open source.
Clang allowed Apple to take their IDE to a whole new level. Since the move to clang, features like code completion, scope higlighting, refactoring tools and inline error display (with somewhat helpful autocorrect suggestions) have vastly improved.
Apple didn't want to get rid of GCC out of spite, butthe restrictions of the GPL were holding them back. If you are a supporter of copyleft licenses, you'll see this as a success (hindering proprietory software), but from Apple's perspective it is obvious why they chose to support a compiler with a more liberal license.
And a major problem with GCC related to the GPL is that it has historically resisted changes which would make it easier to integrate even into an open-source project, though it has eased up on this a bit lately (possibly due to competition from clang?) Still, there's a reason that code completion and other code-aware plugins for things like vim and emacs are increasingly clang-based.
Commercial software usually has the same problem. Those dang companies won't give me their source for free, and they demand a license fee to integrate their products into mine!
The issue with the GPL is less the GPL than the multitude of authors for any one project. There are many single-author GPL projects which happily accept money for a non-GPL version of the software.
That becomes much harder when you have 40 authors, some of whom are dead..
This is not accurate in any respect. It would be accurate if you said "early development" (original development was sponsored by UIUC).
Their interest in the project was not at all in excising the GPL. They didn't care. That was a political position they took once on a GCC mailing list. But lawyers do not run Apple. If they wanted to keep using GCC, they would have kept using GCC.
They wanted faster build times, a better infrastructure, and something they felt they could invest in and not have this amazing uncertainty about where it was going and what it's goals were. They also didn't want to have engineering stymied by the politics of GCC (it is less political now, it was very political then).
Or it could be a frontend for a new proprietary language.
Or a backend for a whole new architecture.
The versions of Clang and LLVM that you have today will ALWAYS be available under the license they're currently under.
You're fear-mongering that the current contributors of Clang and LLVM may, in the future, make new releases under licenses you don't like.
But if people like Clang and LLVM, they can fork the current code, and keep adding features to it under a compatible FOSS license.
Both projects are politically motivated. GCC began explicitly as a project to provide a FOSS C compiler (few if any existed at the time). Clang/LLVM didn't start at Apple, but their development has been heavily sponsored by Apple, whose interest in the project stems from their interest in excising the GPL (and specifically the GPLv3) from their entire development stack. (Notice how the version of bash that ships with OS X is almost a decade old, and is also the last version that was released under GPLv2).
The fact that Clang/LLVM are released under a FOSS license today does not mean (A) that they always will be, or (B) all essential functionality will always be[0]. With GCC, being a FOSS compiler collection is their entire raison d'etre - it's right in the name![1]
Edit: Reworded sentence to remove ambiguous antecedent.
[0] (ie, it's conceivable in the future that nobody will want to use Clang/GCC on its own, but will essentially have to use it in conjunction with another piece of related software, and there's no guarantee that this software will be FOSS. With GCC this is not a relevant concern only because the FSF would never let that happen; it undermines the entire founding point of the project.
[1] GNU Compiler Collection