LLVM 3.0 released

[Posted December 1, 2011 by corbet]

From:		Chris Lattner <clattner-AT-apple.com>
To:		llvm-announce-AT-cs.uiuc.edu
Subject:		LLVM 3.0 Release!
Date:		Thu, 01 Dec 2011 13:49:47 -0800
Message-ID:		<268E6F9F-5D76-40BE-A641-57BD06BBDA5E@apple.com>

Hello LLVM People,

Welcome to LLVM 3.0! Get it here: http://llvm.org/releases/
or read about it: http://llvm.org/releases/3.0/docs/ReleaseNotes.html

This release represents approximately 6 months of development over 
LLVM 2.9, and delivers a large number of improvements.  Some of the
bigger leaps include a new register allocator (which can provide
substantial performance improvements in generated code), full support
for atomic operations and the new C++ memory model, major improvement
in the MIPS backend, and support for gprof/gcov style of profiling
information.  In addition to these enhancements, there are countless
smaller improvements - please see the release notes for more
information and details.

Though this release is another incremental improvement over LLVM 2.9,
the "3.0" number gives us the excuse to drop some old baggage.  As
such, LLVM 3.0 no longer includes support for the llvm-gcc frontend
(please use Clang or Dragonegg instead) and does not read LLVM .bc or
.ll files from LLVM 2.8 or earlier.  Our goal is for *all* future
releases of LLVM to be able to read LLVM 3.0 files, making it a
stable file format.

Speaking of Clang, Clang 3.0 has also made numerous big leaps in this
release: many new C'1x and C++'11 (aka C++'0x) features are
implemented and it supports the Objective-C 'Automatic Reference
Counting' system.  Clang generates faster code, compiles faster, and
produces even better error and warning messages than LLVM 2.9.
Clang also includes its own release notes for this release with many
more details:
http://llvm.org/releases/3.0/docs/ClangReleaseNotes.html

This release would not be possible without our volunteer release team.
Thanks to our release manager Bill Wendling, as well as Duncan Sands,
Anton Korobeynikov, Conrad Taylor, Jonas Bülow, Roman Divacky, Pawel
Worach, NAKAMURA Takumi, Joe Abbey, Nikola Smiljanic, and Tanya Lattner
for their work to qualify and shepherd the release.

If you have questions or comments about this release, please contact
the LLVMdev mailing list!  Onward to LLVM 3.1!

-Chris

LLVM Release Announcement Linked List:
http://lists.cs.uiuc.edu/pipermail/llvm-announce/2011-Apr...

LLVM 3.0 released

Posted Dec 2, 2011 0:48 UTC (Fri) by kragilkragil2 (guest, #76172) [Link] (31 responses)

Really cool. LLVM seems to have lots of traction.

I wasn't aware that RenderScript uses LLVM.
I also never heard of Crack(very GIMPy name, for better or worse) and Tart Programming Language. Crack could be something I was looking for. A kind of Vala for C++. Especially Qt could use something Vala-like to ease development and put best practices and Qt at the heard of the language.(I know all the C++ lovers will disagree, but I would love to have something that compiles and is not C++ for Qt)
Vala got a lot of traction in the Gnome world. Qt could really use something similar.

LLVM 3.0 released

Posted Dec 2, 2011 12:44 UTC (Fri) by pboddie (guest, #50784) [Link] (1 responses)

Those languages are reminiscent of Boo, Cobra, Delight, Wirbel and Dart amongst others. I think everyone must have an explicitly-typed, semi-dynamic language on the go these days.

LLVM 3.0 released

Posted Dec 2, 2011 15:52 UTC (Fri) by jengelh (guest, #33263) [Link]

I would rather prefer if they would use a unified one rather than everybody having to make their own soup.

LLVM 3.0 released

Posted Dec 2, 2011 16:13 UTC (Fri) by hengestone (guest, #81664) [Link] (28 responses)

I may be speaking out of turn, but you'll be happy to know a Smoke binding for Crack/Qt is in development.

Check it out, there should be an Ubuntu PPA to install from soon.

LLVM 3.0 released

Posted Dec 2, 2011 23:45 UTC (Fri) by kragilkragil2 (guest, #76172) [Link] (27 responses)

Cool, that is excelent news. Last message about that that I saw was from 2010. Will the integration be as tight as with Vala and GTK/Gobject/Glib?
I think the only way a new language can gain ground is by doing one thing better than all the alternatives. Like Vala does right now, it seems to be the prefered language for GTK/Gnome development right now. Even for some system tools, which is quite amazing.

LLVM 3.0 released

Posted Dec 5, 2011 9:14 UTC (Mon) by epa (subscriber, #39769) [Link] (26 responses)

If the alternative is C, it is relatively easy to do one thing better. You do have to exercise a bit of discipline and improve just one or two things, otherwise you end up with C++.

LLVM 3.0 released

Posted Dec 5, 2011 19:00 UTC (Mon) by viro (subscriber, #7872) [Link]

... thus demonstrating that piling improvement upon improvement can lead to overall regression, unless you happen to have a really good taste and not a small amount of luck?

LLVM 3.0 released

Posted Dec 5, 2011 19:30 UTC (Mon) by rgmoore (✭ supporter ✭, #75) [Link]

Brooks discussed this exact problem in The Mythical Man Month; he describes it as the second system effect. Designers try to improve their second design by adding all the features they were forced to leave out of the first one, which winds up bloating it out of control. I suspect that time-based releases, and a philosophy of frequent releases in general, are beneficial partly because they restrain architects from adding too much in one go. If you know you have a limited time until the next release, you're forced to be choosy about what you add.

LLVM 3.0 released

Posted Dec 6, 2011 14:14 UTC (Tue) by HelloWorld (guest, #56129) [Link]

95% of all weak spots in C++ can be traced back directly to flaws in C.

LLVM 3.0 released

Posted Dec 6, 2011 22:48 UTC (Tue) by daglwn (guest, #65432) [Link] (22 responses)

Oh please, don't start that war again. C++ is a fine language used in tons of production code. Is it perfect? No. Is any language perfect? No.

LLVM 3.0 released

Posted Dec 7, 2011 3:24 UTC (Wed) by k8to (guest, #15413) [Link] (20 responses)

Regardless of opinions, the statement is merely factual on the basis of complexity. No need to treat as bait.

LLVM 3.0 released

Posted Dec 7, 2011 15:39 UTC (Wed) by daglwn (guest, #65432) [Link] (19 responses)

It is not factual at all. It is opinion. One person's "complexity" is another's "complete specification."

LLVM 3.0 released

Posted Dec 7, 2011 20:22 UTC (Wed) by k8to (guest, #15413) [Link] (18 responses)

Believe it or not, it's really quite factual that C++ has a higher level of complexity than C. From any point of view at all. Syntax tree, feature set, number of possible combined keywords, conceptual domain, application, space, ... there's really no aspect where it isn't true. Similarly a mandelbrot outline has a higher level of complexity than a circle.

You mistake something that you believe to be a debating point for something that can actually be debated.

LLVM 3.0 released

Posted Dec 7, 2011 23:08 UTC (Wed) by daglwn (guest, #65432) [Link] (15 responses)

Of course C++ is more complex than C. It's more powerful. The implication of the original message is that this complexity is bad. It's not bad. It simply is. C++ allows a kind of expressivity not achieved before nor since by any other language. That doesn't mean it's the best language for every job, but simply that it aggregates and unifies a bunch of features in novel and unique ways.

That's not bad. That's progress.

LLVM 3.0 released

Posted Dec 8, 2011 8:27 UTC (Thu) by thedevil (guest, #32913) [Link] (8 responses)

"C++ allows a kind of expressivity not achieved before nor since by any other language"

Extremely dubious. I am sure you can come up with examples (both before and after) yourself.

To make it even close you'd need to add a qualifier like "... that is mostly compatible with C". Even then it is not a closed case.

LLVM 3.0 released

Posted Dec 9, 2011 16:48 UTC (Fri) by daglwn (guest, #65432) [Link] (7 responses)

What other language aggregates inheritance, exceptions, fully generic programming and pattern matching AND specifies their interactions completely?

None that I know of. Not even without the "compatible with C" qualifier. Perhaps there is an esoteric project somewhere that does this but certainly no other mainstream language. C++ doesn't have every language feature possible but it does have a unique combination of them.

LLVM 3.0 released

Posted Dec 10, 2011 3:33 UTC (Sat) by Cyberax (✭ supporter ✭, #52523) [Link] (1 responses)

"D" does this and has much more powerful metaprogramming system.

Alas, no real manual memory management.

LLVM 3.0 released

Posted Dec 12, 2011 4:20 UTC (Mon) by daglwn (guest, #65432) [Link]

D isn't exactly mainstream, but I'll grant that it has some great ideas. Forced garbage collection is a huge drawback as you point out.

LLVM 3.0 released

Posted Dec 10, 2011 9:33 UTC (Sat) by paulj (subscriber, #341) [Link] (4 responses)

Vala does everything that I like from C++, without C++s innumerable odd cornercases or legacy cruft/baggage.

LLVM 3.0 released

Posted Dec 12, 2011 4:18 UTC (Mon) by daglwn (guest, #65432) [Link] (3 responses)

Vala is certainly interesting, but it doesn't do everything C++ does, even ignoring the legacy stuff. I know it may not be stuff that you need but it is stuff I use a lot. For example, there is no true multiple inheritance in Vala. There's no pattern matching of generic classes, hence no metaprogramming. There's not complete static typing, which IMHO is a huge loss when trying to use a language for very large projects.

Vala is cool. I definitely see the value in it. But it isn't a replacement for C++.

LLVM 3.0 released

Posted Dec 12, 2011 7:17 UTC (Mon) by paulj (subscriber, #341) [Link] (2 responses)

Vala does have multiple inheritance, or at least I don't see how its mixins are fundamentally any different:

http://live.gnome.org/Vala/Tutorial#Interfaces_.2BAC8_Mixins

Vala has generics. I'm not sure what aspect of C++ templates you miss, but I sure don't miss the multiple-pages or more of incomprehensible error messages that are inherent to even minor mistakes with C++ templates. ;)

Vala is statically typed, not sure why you'd think otherwise (it allows type inference of LHS in assignments with "var x = y;" - a handy convenience, and still statically typed).

LLVM 3.0 released

Posted Dec 12, 2011 10:11 UTC (Mon) by mpr22 (subscriber, #60784) [Link] (1 responses)

As that page describes it, Vala allows you to inherit at most one class and any number of interfaces (and the page explicitly says that it's a restricted form of multiple inheritance). C++ allows you to inherit multiple concrete classes. (It happens to be the case that I've never encountered a case where I thought I had a reason to use this capability, but I am not every C++ programmer.)

LLVM 3.0 released

Posted Dec 12, 2011 10:38 UTC (Mon) by paulj (subscriber, #341) [Link]

So, it's perhaps a little hidden away in one sentence of the last paragraph of that interface/mixin section, but Vala interfaces may contain concrete implementations. I.e. Vala has multiple inheritance - the only difference in Vala is that the classes being inherited from must mark themselves as being comfortable with that (not a fundamental difference).

LLVM 3.0 released

Posted Dec 8, 2011 9:29 UTC (Thu) by k8to (guest, #15413) [Link]

Whether these adiditional aspects of complexity are worth it are a mattter of significant deabate, and not likely to be resolved here. I do not mean to try to resolve that matter here. I appreaciate that you have shown acceptance that the factual matter is indeeed factual. Adding the kitchen sink to C (as with C++) results in a remarklaably more complex language. It may be worth it. I don't personally believe it is, but I have preciously little objective basis for this judgement.

LLVM 3.0 released

Posted Dec 13, 2011 18:39 UTC (Tue) by dgm (subscriber, #49227) [Link] (4 responses)

> Of course C++ is more complex than C. It's more powerful.

Both are Turing-complete, and thus are equivalent in power (as in what you can write with them). Maybe you wanted to use the term "expressive", but that's not very well defined (http://en.wikipedia.org/wiki/Comparison_of_programming_la...). In fact, according to that article, Python, Smalltalk and Perl are more expressive than C++ (and much more than C).

LLVM 3.0 released

Posted Dec 13, 2011 20:17 UTC (Tue) by nybble41 (subscriber, #55106) [Link] (3 responses)

Both C and C++ are Turing-complete[1], but AFAIK only C++ has a built-in Turing-complete metaprogramming interface at compile time in the form of templates. That can reasonably be considered an extra measure of power. (Retaining one's sanity while attempting any complex computation with C++ templates is left as an exercise for the reader.)

[1] See also: "Turing tarpit" <http://en.wikipedia.org/wiki/Turing_tarpit>

LLVM 3.0 released

Posted Dec 13, 2011 21:27 UTC (Tue) by mathstuf (subscriber, #69389) [Link] (1 responses)

> only C++ has a built-in Turing-complete metaprogramming interface at compile time in the form of templates

Haskell has Template Haskell[1][2] (it's an extension, but since GHC is pretty much the only compiler for Haskell, that's pretty much moot).

[1]https://en.wikipedia.org/wiki/Template_Haskell
[2]http://www.haskell.org/haskellwiki/Template_Haskell

LLVM 3.0 released

Posted Dec 13, 2011 21:49 UTC (Tue) by nybble41 (subscriber, #55106) [Link]

Sorry, I didn't mean "only C++" in that sense. I was only considering C and C++. Other languages do have decent metaprogramming facilities as well, some (IMHO) much better than C++ templates. Lisp macros, for example, or Scheme's syntax expanders. D's more flexible template system ranks highly as well, though the syntax isn't quite as consistent and it relies on parsing generated strings, rather than constructing syntax objects directly.

LLVM 3.0 released

Posted Dec 14, 2011 1:14 UTC (Wed) by dgm (subscriber, #49227) [Link]

Very interesting reading. I came to the conclusion that C++ templates could be considered a meta-Turing tarpit.

LLVM 3.0 released

Posted Dec 9, 2011 16:33 UTC (Fri) by HelloWorld (guest, #56129) [Link] (1 responses)

> Believe it or not, it's really quite factual that C++ has a higher level of complexity than C.
Yes, but does that matter? Personally, I don't care too much about language complexity, I care about the complexity of software written in a language, and C tends to make even simple things harder than they need to be.

LLVM 3.0 released

Posted Dec 10, 2011 2:46 UTC (Sat) by rgmoore (✭ supporter ✭, #75) [Link]

To some extent, simplicity is in the eye of the beholder. Code that uses the extra expressiveness of a more feature rich language can be shorter and easier to read and write, but only within limits. It may be easier to read or write one fancy function instead of three simple ones, but only if you remember what the fancy function does. As soon as you expand your vocabulary beyond what people can remember, you waste more time looking through documentation than you save by making things more compact. Of course "what people can remember" varies from person to person, but the rare function call that sends people scurrying to figure out what it does is a real danger of a big language.

LLVM 3.0 released

Posted Dec 14, 2011 11:21 UTC (Wed) by epa (subscriber, #39769) [Link]

I prefer C++ to C, and often come out to defend C++ when these theads pop up on LWN or Slashdot, but I stand by what I wrote. C has plenty of small flaws, and it is easy to make a C-like language that fixes just one or two of them (for example, Cyclone). If you add too much stuff to the C substrate then you will get something like C++, and the world doesn't need another of those, one is sufficient.