

LLVM and Clang 3.2 released - japaget
http://llvm.org/docs/ReleaseNotes.html

======
Arjuna
For those that follow game development, John Carmack had this to say at
QuakeCon 2012:

 _"But, one of my pushes on the greater use of static analysis and
verification technologies, is I pretty strongly suspect that the Clang LLVM
sort of ecosystem that's living on OS X is going to be, I hope, fertile ground
for a whole lot of analysis tools and we'll wind up benefiting by moving more
of our platform continuously onto OS X just for that ability to take advantage
of additional tools there."_ [1]

[1] <https://www.youtube.com/watch?v=wt-iVFxgFWk#t=45m4s>

------
msutherl
I love the community of languages that have adopted LLVM as a back-end:
[http://llvm.org/docs/ReleaseNotes.html#external-open-
source-...](http://llvm.org/docs/ReleaseNotes.html#external-open-source-
projects-using-llvm-3-2)

Pure, FAUST, Julia, Clay are all very promising and I didn't know about Open
Shading Language or Portable OpenCL.

[1] <http://code.google.com/p/pure-lang/>

[2] <http://faust.grame.fr/>

[3] <http://julialang.org/>

[4] <http://claylabs.com/clay/>

[5] <https://github.com/imageworks/OpenShadingLanguage/>

[6] <http://pocl.sourceforge.net/>

~~~
pohl
Haskell and Rust are also worthy of mention here.

~~~
ch0wn
Does GHC use the LLVM backend by default or do you have to manually enable
that?

~~~
ionfish
No, the default backend is the native code generator. You need to use the
-fllvm flag to enable the LLVM backend.

[http://www.haskell.org/ghc/docs/7.6.1/html/users_guide/code-...](http://www.haskell.org/ghc/docs/7.6.1/html/users_guide/code-
generators.html)

"[The LLVM backend] is an alternative backend that uses the LLVM compiler to
produce executable code. It generally produces code as with performance as
good as the native code generator but for some cases can produce much faster
code. This is especially true for numeric, array heavy code using packages
like vector. The penalty is a significant increase in compilation times."

------
jonpaul
Admittedly, I don't write much C/C++ anymore, but for a recent project, I need
to use C. I decided to try clang instead of gcc. When clang showed me exactly
what the source (via colors and indicators) of my compilation error I
immediately knew that clang is the way forward.

------
richdougherty
Use this link instead: <http://llvm.org/releases/3.2/docs/ReleaseNotes.html>

The original link points to some draft version with lots of placeholder text
throughout.

------
benbjohnson
Another great LLVM tool that I don't see much press about is scan-build. It
does static analysis and lets you navigate the results in your web browser. I
believe Xcode builds this in but it's nice for anyone not using an IDE.

<http://clang-analyzer.llvm.org/scan-build.html>

------
jws
Doxygen users will be glad to know that Clang now can syntax check your
Doxygen comments.

~~~
jevinskie
-Wdocumentation, FYI

------
ditoa
Anyone using LLVM/Clang on Windows? If so did you have to do anything special
to get it to work? I have not really looked into it much myself as the last
time I did Windows was basically a no go. Any advice would be great thanks!

~~~
ryanmolden
I've toyed with it a bit. The three biggest problems are probably the
inability to link with libs that were compiled with MSVC (they are working on
being able to make and consume libs that are MSVC compatible, but it isn't
there yet), problems parsing Windows based source code (i.e. things knowingly
or unknowingly relying on MSVC only extensions), and problems with some of the
MS STL headers, particularly in 2012 type_traits and some non-conformant macro
expansion behavior in MSVC that Clang hasn't emulated (so parsing headers
using macros that rely on said expansion behavior fails). I have a patch
proposed for the type_traits issues and am waiting for some feedback from
Chandler on the patch. It has already been reviewed/signed off on by two
others, so hopefully acceptance is close. I believe there are patches for the
macro issue the floating around, but they haven't been committed since when
one was it broke building gtest :(

~~~
marshray
I'd love it if Clang could accept decently-compliant C++11 source and emit
something that MSVC could compile. Like the old Comeau C++ did.

------
nhutchinson
It looks like the Clang binaries for 32-bit Ubuntu try to produce 64-bit
executables by default:

    
    
        # clang -v
        clang version 3.2 (tags/RELEASE_32/final)
        Target: x86_64-unknown-linux-gnu
        Thread model: posix
        # clang hello_world.c
        /usr/include/features.h:324:10: fatal error: 'bits/predefs.h' file not found
        # clang -m32 hello_world.c  # (No error)
        

That's not right, surely?

~~~
azakai
Sure you didn't download the 64-bit binaries? The 32-bit ones look fine to me.

If you see that on 32-bit ones, file a bug.

------
mikevm
Why would one prefer to use LLVM over GCC?

~~~
jetti
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.

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

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

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

~~~
pooriaazimi
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.

------
jrajav
The highlight of this release for me: built-in support for the ObjFW
Objective-C runtime.

<https://webkeks.org/blog/?5f>

~~~
joshavant
So an Apple engineer spent time adding support for more 'liberal', non-Apple-
based Objective-C runtimes? Wow!

That seems unusual of Apple, but very cool.

EDIT - Looking at the clang source, it looks like GNUstep and and ObjFW (with
the exception of old GCC) are the only alternative Objective-C runtimes
currently supported by clang:
<http://clang.llvm.org/doxygen/ObjCRuntime_8h_source.html>

~~~
gsnedders
Unusual? It'd seem beneficial to Apple in several ways, in that they have
multiple ABIs (see the code there!), and in that it keeps other Obj-C users
interested in Clang (which means more outside work on the Obj-C frontend).

------
corresation
It went largely unnoticed, but one of the biggest changes of the November
Android NDK release was the addition of LLVM/clang to the toolchain. This was
primarily added to reduce issues when cross-compiling iOS apps to Android.

~~~
zbowling
unfortunately it ships with older 3.1 version and not 3.2 so for porting it's
not the greatest. You can use clang without google's changes just fine though
(just have to get the PIC and pie flags right). A few bugs fixed with C++ on
android in google's version but nothing major. Or better yet, you can wait
until the Apportable SDK is publicly released so your objective-c apps can run
on Android. :-)

------
eli_gottlieb
Welp, now I had better go update jllvm to 3.2.

------
ronnix
Are they?

~~~
dochtman
Read the actual, complete release notes here:

LLVM, <http://llvm.org/releases/3.2/docs/ReleaseNotes.html>

Clang: <http://llvm.org/releases/3.2/docs/ClangReleaseNotes.html>

The project has recently moved to Sphinx, and the transition was only
completed after branching for 3.2. It looks like the release notes have gotten
out of sync and need to be merged, which is a little more work than usual. The
link from the homepage points to docs that are always generated from trunk, so
it only has old, incomplete notes.

