I bought the new XCode 4 recently and it is a pretty awesome IDE. I only recently got into Objective-C coding, but I have VERY quickly fallen in love with the language and the IDE.  I generally regarded my language of choice to be Java and my all time favorite IDE has been Eclipse, but I’d have to say XCode and Objective C comes very very close to dethroning the Java/Eclipse combo.

Having said this, though, adapting to XCode 4 is a bit of a challenge after using XCode 3 for a while.  Have a look at this awesome review of XCode 4.  It helped me make some sense of the new features and how to wrap my head around using this magnificent beast.  As of this post, the one major point that I absolutely hated about XCode 4 is the actual purchase/download process.  It took me about 10 hours to download its gargantuan 4.5GB on a 6Mbit line.

Now that that’s out of the way, I wanted to get down to one of the front-page features of XCode 4: LLVM.  The Apple XCode page states:

“Apple’s next generation compiler technology, the Apple LLVM compiler, does more than build your app. Apple LLVM technology is integrated into the entire development experience. The same parser used to build C/C++ and Objective-C powers Xcode’s indexing engine, providing incredibly accurate code completions. As you work, Apple LLVM is constantly evaluating what you type, identifying coding mistakes that Xcode shows as Live Issues, and thinking ahead for ways to Fix-it for you. Other compilers can tell you what is wrong — Apple LLVM can make it right.”

Being the curious type, I thought I’d give LLVM, or more specifically Clang, a try.  I figured the best way to do this is to compare a program compiled with Clang against the same one compiled with the venerable GCC compiler.  While there are benchmarks that were done in 2010 (here and here), I wanted to verify how the latest version of Clang would perform.

My test environment:

1. OS X 10.6.8 running on a Core 2 Duo 13″ MacBook
2. Clang version 2.0 based on LLVM 2.9svn
3. GCC version 4.2.1 build 5666
4. John the Ripper 1.7.8 Jumbo 2 from source

To start off, I thought I’d test how long each compiler would take to build JTR.  I made two copies of the JTR source under “john-llvm” and “john-gcc”.  Then I edited the “john-llvm” Makefile and changed the “CC” parameter to “clang” from the default value of “gcc”.  I ran “make macosx-x86-64″ on both directories after that.  Here are the respective build times (I used “time” to time the builds):

Clang:

1. real 0m41.382s
2. user 0m37.316s
3. sys 0m2.648s

GCC:

1. real 0m38.721s
2. user 0m34.067s
3. sys 0m3.540s

I then ran “john –test” on each build.  Here are the results for the “OpenBSD Blowfish (x32) [32/64 X2]” test:

Clang:

260 c/s real, 257 c/s virtual

GCC:

410 c/s real, 410 c/s virtual

Conclusion

Admittedly, I haven’t used any sophisticated test frameworks, and I’ve done more or less a “layman’s” set of tests.  But the results are clear: JTR compiled with GCC will crack your Blowfish password in half the time it would take for JTR compiled with Clang to do so.  It also takes less time to build JTR using GCC than it does to build it with Clang.

Obviously the hardware has a lot to do with test results and also the OS.  It would be interesting to see what the results look like when Lion is released this month.