Hacker News Reader

Comment by mikevm | Hacker News Reader

Why would one prefer to use LLVM over GCC?

As somebody who is learning C++ and decided to go with clang, the error reporting is absolutely phenomenal. It tells me not only what line errors are on but also makes suggestions as to how to fix it. I don't ever recall GCC having very helpful error messages.

Agree. Clang vs. GCC is like PostgreSQL vs. MySQL (regarding usefulness of error messages).

However, in C language features GCC becomes PostgreSQL and Clang becomes MySQL (Things like nested functions to name one).

Is that C language features or compiler-specific extensions? Arguably, sticking to the standard is actually the better alternative here in terms of portability.

You're right - it's a compiler extension to a language (apparently) called "GNU C"[1]: http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html

Seems like a very nice feature though.

[1]: First time I've heard this term. I'm not sure how I feel about it.

You can usually use "-std=c99" to ban features of concern.

Clang has blocks, which, while different, are at least an arguably superior replacement for gcc's nested functions.

GCC has nested functions, which most GCC users hate. Clang has blocks, which are at least widely used on OS X at least and proposed for standardization. I'm not sure this is a point in GCC's favor.

As an Objective-C (iOS) developer, I really love blocks. I thought the syntax was kind of weird when starting to learn it, but it's grown on me. I really hope ObjC blocks will become part of the C standard someday. If I remember people have proposed C++ lambdas to become part of the C standard as well. It will be interesting to see which one (if any) will win in a standardising process.

More info on ObjC blocks vs C++ lambdas in this blog posting: http://www.mikeash.com/pyblog/friday-qa-2011-06-03-objective...

LLVM has a BSD-license. This might be a big deal for some people from a philosophical perspective, but at a more practical level it's great when you need to embed a compiler in your product.

What kind of products allow users to compile and run custom C code, but would feel constrained by the GPL? Any examples (OSX excluded)?

I'm working on an Apache-licensed product that uses some of it's libraries for code generation.

It has nothing to do with "custom C code". Any tool with a custom language (or equivalent) that wants a runtime JIT for the language and code compilable to LLVM IR would need to link in the compiler libs to do that. Custom DSLs are everywhere.

For example, OpenShadingLanguage compiles shaders on the fly as part of a physically-based renderer, and then JITs them at runtime with LLVM. Linked in are the LLVM libs and a bunch of C code that is converted to LLVM IR and accessed by the shaders. The whole lot is linked and JITd together, enabling interprocedural analysis, inlining and a bunch of other compiler optimizations (e.g. constant folding). The resulting shaders are about 25% faster than their previous, hand-coded C shaders.

IOW, lots of products benefit from having a compiler toolchain at runtime they can link with their program. GPL license or not, GCC isn't made to do that.

XCode. GCC is now under GPLv3. I've got a feeling the patent issues in v3 give Apple lawyers a serious rash.

Also with it being under BSD, they can write their own closed source extensions or reuse portions of their code in their own projects.

Suppose you're writing an IDE, and you want to use the clang code to do the heavy lifting of making your editor aware of your program's AST, so that you can easily colorize it, provide in-line warnings & errors, and offer fix-it suggestions.

Cloudera Impala uses LLVM to generate code optimized for the specific query it is running (basically compiling away all the generalness around how large records are, etc). Some kind of native code generation is apparently standard practice in high-performance query engines that are written in languages that don't have a JIT.

Why would it have to be "C code"? LLVM can compile any kind of code with the appropriate front-end. For example, Apple uses it in their OpenGL pipeline, in the (previously Apple sponsored) MacRuby, etc.

A few months ago there was a discussion about the problems with the licenses in the Racket Users mailing list:

(first mail) http://lists.racket-lang.org/users/archive/2012-April/051303...

(most relevant mail) http://lists.racket-lang.org/users/archive/2012-April/051319...

They use the LGPL license. The idea is that you can make closed source programs that link to the Racket system as a library, but you must provide a version that is linkable to newer versions of Racket. But in Racket the macro expansions are a fundamental part so the more strict interpretation means almost that you must provide the original source code in plain text.

I don't know enough about licenses, perhaps this is only FUD. And my impression is that the intensions of the Racket creators is that closed source programs in Racket are allowed, but this looks like a gray area.

And the GPL license is more restrictive, but C/C++ has many less macros/templates than Racket.

http://clang.llvm.org/comparison.html

Because both LLVM and Clang are librarified from the off, so you can hook them into your own code and use as much or as little of them as you want. You can insert your own passes, make your own drivers, add your own analyses to the static analyzer (http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf). Or use it to get information to show in an IDE.

Reply on news.ycombinator.com