Reply With QuoteThis serves as a nice example of the BSD license chat in the forum.
The parts of libc++ that are better than gcc's can just be copy-pasted there, changed to GPL, and further improvements can't be returned to llvm. Good for gcc though
Phoronix News Bot
LLVM Replaces libstdc++ Library With libc++
Phoronix: LLVM Replaces libstdc++ Library With libc++
The LLVM compiler infrastructure project has Clang as a compiler front-end to compile C, Objective-C, and C++ programs as an alternative to GCC. However, the Low-Level Virtual Machine is now doing more and replacing bigger portions of the GCC tool-chain with new components. The LLVM project has introduced libc++ as a replacement for the GNU libstdc++ standard library...
http://www.phoronix.com/vr.php?view=ODI1NQ
Senior Member
This serves as a nice example of the BSD license chat in the forum.
The parts of libc++ that are better than gcc's can just be copy-pasted there, changed to GPL, and further improvements can't be returned to llvm. Good for gcc though
Senior Member
Not quite. You'd need to comply with the BSD-style license, which means you need to have that notice in the file. And that means the file falls under the GPL *and* the BSD-style license. You can't just change the license of a work without consent of the author.Originally Posted by curaga
This serves as a nice example of the BSD license chat in the forum.
The parts of libc++ that are better than gcc's can just be copy-pasted there, changed to GPL, and further improvements can't be returned to llvm. Good for gcc though
Senior Member
In simple words you do what Curaga said and just mention original authors.
Senior Member
http://lists.cs.uiuc.edu/pipermail/c...ay/009016.htmlThere's some tests on the mailing list showing it being much faster than libstdc++: 5 seconds versus 22 seconds.
It reminds me some funny freebsd devs.Errr, that is a pretty old version at this point.
Also this was before significant performance improvements were target
at libstdc++ *and* g++.
It seems a bit strange to compare something from today to something
that is now 3 release versions old.
Senior Member
No, you need to place that exact notice in the file. That notice that gives users the rights of the BSD style license. The actual words:
http://www.opensource.org/licenses/UoI-NCSA.php
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimers.
Junior Member
Why is Apple dumping time and effort into clang? I know they don't like being tied to gcc because of the GPL license, but again, why? I have a feeling that they want clag so badly is so they can rebrand it to "iCompiler" and charge for that too.
Senior Member
Including the notice is not an issue. Any further improvements to it would still be under GPL, and so impossible to get back to the original project without the respective authors' consent.
Senior Member
If you put a file on the internet with a BSD style notice and a GPL notice on top of it, then you can't claim that your changes are GPL only. They are licensed GPL *and* they are licensed BSD. That means any user can choose a license, and obey that one.
Moderator
What a bunch of paranoia. Apple has never charged for it's compiler suite. It' has come standard with every OS X release and can be easily downloaded as well. The advantages and benefits of clang over GCC is easily found on wikipedia.
http://en.wikipedia.org/wiki/Clang
Clang is a new C-targeted compiler intended specifically to work on top of LLVM.[8] The combination of clang and LLVM provides the majority of a toolchain, allowing the replacement of the whole GCC stack.
One of clang's primary goals is to better support incremental compilation to allow the compiler to be more tightly tied to the IDE GUI. GCC is designed to work in a "classic" compile-link-debug cycle, and although it provides useful ways to support incremental and interrupted compiling on-the-fly, integrating them with other tools is not always easy. For instance, GCC uses a step called "fold" that is key to the overall compile process, which has the side effect of translating the code tree into a form that does not look very much like the original source code. If an error is found during or after the fold step, it can be difficult to translate that back into a single location in the original source. Additionally, vendors using the GCC stack within IDEs used separate tools to index the code to provide features like syntax highlighting and autocomplete.
Clang is designed to retain more information during the compilation process than GCC, and preserve the overall form of the original code. The objective of this is to make it easier to map errors back into the original source. The error reports offered by Clang are also aimed to be more detailed and specific, as well as machine-readable, so IDEs can index the output of the compiler during compilation. Since the compiler is always running, it can offer source code indexing, syntax checking, and other features normally associated with rapid application development systems[vague]. The parse tree is also more suitable for supporting automated code refactoring, as it remains in a parsable text form at all times. Changes to the compiler can be checked by diffing the IF.
GCC systems don't support threading at the single compilation level and cannot take advantage of the multi-processor hardware for single compilation units. Clang was designed from the start to be threaded and aims for reduced memory footprint and increased speed. As of October 2007, clang compiled the Carbon libraries well over twice as fast as GCC, while using about five times less memory and disk space.[10]
Although development on GCC may be difficult, the reasons for this have been well explored by its developers. This allowed the clang team to avoid these problems and make a more flexible system. Clang is highly modularized, based almost entirely on replaceable link-time libraries as opposed to source code modules that are combined at compile time, and well documented. This makes it much easier for new developers to get up to speed in clang and add to the project. In some cases the libraries are provided in several versions that can be swapped out at runtime; for instance the parser comes with a version that offers performance measurement of the compile process.
