Linked by Thom Holwerda on Wed 15th Jun 2011 14:23 UTC, submitted by Valhalla
General Development "PathScale announced today that the EKOPath 4 Compiler Suite is now available as an open source project and free download for Linux, FreeBSD and Solaris. This release includes documentation and the complete development stack, including compiler, debugger, assembler, runtimes and standard libraries. EKOPath is the product of years of ongoing development, representing one of the industries highest performance Intel 64 and AMD C, C++ and Fortran compilers." More here.
Permalink for comment 477565
To read all comments associated with this story, please click here.
Member since:


"As with all GPL programs, the GPL license and the associated copyleft applies to the source code of the program. Youy have unlimited, irrevocable, unconditional permission (under the GPL) to use the program however you wish. The only act to which copyleft provisos apply is if you decide to re-distribute said compiler tools."

Hmm, I don't know if that's right. The binary could arguably be a derivative work.

It's not. This is an old question, with an old answer. Compiled binaries are not derivative works; anything you create with a GPL'ed tool is yours to do with as you please (as is true with any other GPL'ed program that produces something, like the GIMP).

I think the FSF uses a different interpretation of the GPL than common sense might infer, which is why they've licensed GCC with GPL exceptions.

In the faq, read this section "Why is compiler intermediate representation excluded from the definition of 'Target Code?'"

"...If that program is proprietary, the exception will not be available to any software compiled with it; the object code that GCC ultimately creates will have to be distributed under the terms of the GPL."

Let me include the whole FAQ entry in question:

Why is compiler intermediate representation excluded from the definition of “Target Code?”

When we first considered adding a plugin infrastructure to GCC, we were deeply concerned about the possibility that someone would write a plugin that would merely save GCC's internal, low-level compilation data structures to disk. With that done, other software would be able to optimize or otherwise improve that code without being directly connected to GCC. It may have been difficult for us to argue that those programs should be subject to the GPL's copyleft, so we wanted to discourage these sorts of arrangements.

We do that by excluding such output from the definition of Target Code. Because of this, even if someone writes a plugin that saves this information to disk, any programs that change the structures before GCC writes out Target Code will be involved in the Compilation Process. If that program is proprietary, the exception will not be available to any software compiled with it; the object code that GCC ultimately creates will have to be distributed under the terms of the GPL.

What they're specifically talking about here is preventing some "clever" third party from using GCC's plug-in architecture to attempt to circumvent the GPL license covering GCC. Basically, if you use a plug-in to operate on the low-level in-memory structures that GCC is using to compile your code, you don't get the license exception that allows you to include the technically-GPL'ed trivial libraries that GCC is going to link your code with under other licenses. This has no effect on normal use of the compiler.

It's pretty clear that the FSF intends GCC compiled code not covered by the exception to fall under the GPL license.

You really had to torture your reading of that page to get to that conclusion. The very first two paragraphs specifically state that the GCC developers have always intended to support proprietary development, even if they don't particularly like it. The second and third paragraphs of your own link:
The licenses for some libraries that accompany GCC have not been changed yet. These libraries are automatically used by the object code that GCC produces. Because of that, if these libraries were simply distributed only under the terms of the GPL, all the object code that GCC produces would have to be distributed under the same terms. 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 dog.

Therefore, these libraries have always had license exceptions that allow people to distribute the object code GCC produces under any license.
We are now moving these libraries to GPLv3 and updating their exceptions. Our fundamental policy has not changed; the new license is meant to permit all the uses of GCC that were permitted before. However, we have decided to use this opportunity to update the exception to accomplish three goals:

My Bold.

So, first, it is definitely legal to distribute binaries built with GCC under any license, and it is definitely the FSF's intention that that be the case. Second, that page is in its entirety about including license exceptions for "small, trivial libraries" that GCC automatically links into compiled object files specifically so that they can be distributed under proprietary licenses.

If the FSF interpretation of the GPL is accurate (it would be ironic if it wasn't), then in theory a GPL compiler without exceptions can only be used for GPL projects.

Personally I find this interpretation bizarre. At the extreme, there could be license ramifications for all GPL tools like 'sed' or 'grep' lacking explicit exceptions.

Of course I leave it to the capable hands of more knowledgeable posters to explain it to me.

The FSF isn't claiming that the GCC's license applies to code that it generates. That isn't how "derived work" has ever been understood to be defined. What they're saying is that GCC links trivial libraries into the object code that it generates, and that those are covered by the GPL; that's where the "GPL infection" is coming from. Exactly because they felt like it would be inappropriate to force the GPL onto any object file built with the GPL, they included exceptions in the license of those trivial libraries allowing them to be included in proprietary programs.

Reply Parent Score: 2