As described in
last October, the runtime library code used by the GCC compiler (which
implements much of the basic functionality that individual languages need
for most programs) has long carried
a license exemption allowing it to be combined with proprietary software.
In response to the introduction of version 3 of the GPL and the desire
to add a plugin infrastructure to GCC, the FSF has now
the licensing of the GCC runtime code has changed. The FSF wishes to
modernize this bit of licensing code while, simultaneously, using it as a
defense against the distribution of proprietary GCC plugins.
Section 7 of GPLv3
explicitly allows copyright holders to exempt recipients of the software
from specific terms of the license. Interestingly, people who redistribute
the software have the option of removing those added permissions. The new
GCC runtime library license is GPLv3, but with an additional
described in Section 7. That permission reads:
You have permission to propagate a work of Target Code formed by
combining the Runtime Library with Independent Modules, even if
such propagation would otherwise violate the terms of GPLv3,
provided that all Target Code was generated by Eligible Compilation
Processes. You may then convey such a combination under terms of
your choice, consistent with the licensing of the Independent
Anybody who distributes a program which uses the GCC runtime, and
which is not licensed under GPLv3, will depend on this exemption, so
it is good to understand what it says. In short, it allows the runtime to
be combined with code under any license as long as that code has been built
with an "Eligible Compilation Process."
The license defines a "Compilation Process" as the series of steps which
transforms high-level code into target code. It does not include anything
which happens before the high-level code hits the compiler. So
preprocessors and code generation systems are explicitly not a part
of the compilation process. As for what makes an "Eligible Compilation
Process," the license reads:
A Compilation Process is "Eligible" if it is done using GCC, alone
or with other GPL-compatible software, or if it is done without
using any work based on GCC. For example, using non-GPL-compatible
Software to optimize the GCC intermediate representation would not
qualify as an Eligible Compilation Process.
This is where the license bites users of proprietary GCC plugins. Since
those plugins are not GPL-compatible, they render the compilation process
"ineligible" and the resulting code cannot be distributed in combination
with the GCC runtime libraries. This approach has some interesting
- "GPL-compatible" is defined as allowing combination with GCC. So a
compilation process which employs a GPLv2-licensed module loses
- This must be the first free software license which discriminates on
the basis of how other code was processed. Combining with proprietary
code is just fine, but combining with free software that happens to
have been run through a proprietary optimizing module is not allowed.
It is an interesting extension of free software licensing conditions
that could well prove to have unexpected results.
- While the use of a proprietary GCC module removes the license
exemption, using a 100% proprietary compiler does not. As long as the
compiler is not derived from GCC somehow, linking to the GCC runtime
library is allowed.
material released with the license change includes this
However, the FSF decided long ago to allow developers to use GCC's
libraries to compile any program, regardless of its license.
Developing nonfree software is not good for society, and we have no
obligation to make it easier. We decided to permit this because
forbidding it seemed likely to backfire, and because using small
libraries to limit the use of GCC seemed like the tail wagging the
With this change, though, the FSF is doing exactly that: using its "small
libraries" to control how the to-be-developed GCC plugin mechanism will be
used. It will be interesting to see how well this works; if a vendor is
truly determined to become a purveyor of proprietary GCC modules, the
implementation of some replacement "small libraries" might not appear to be
much of an obstacle. In that sense, this licensing truly could backfire:
it could result in the distribution of binaries built with both proprietary
GCC modules and a proprietary runtime library.
But, then, that depends on the existence of vendors wanting to distribute
proprietary compiler plugins in the first place. It is not entirely clear
that such vendors exist at this point. So it may well end up that the
runtime exemption will not bring about any changes noticeable by users or
developers, most of whom never thought about the runtime exemption in its
previous form either.
to post comments)