Why do I get a faster binary with XCode's llvm vs. clang++ from MacPorts?

I have written a benchmark method to test my C++ program (which searches a game tree), and I am noticing that compiling with the "LLVM compiler 2.0" option in XCode 4.0.2 gives me a significantly faster binary than if I compile with the latest version of clang++ from MacPorts.

If I understand correctly I am using a clang front-end and llvm back-end in both cases. Has Apple made improvements to their clang/llvm distribution to produce faster binaries for Mac OS? I can't find much information about the project.

Here are the benchmarks my program produces for various compilers, all using -O3 optimization (higher is better):

(Xcode) "gcc 4.2": 38.7
(Xcode) "llvm gcc 4.2": 51.2
(Xcode) "llvm compiler 2.0": 50.6
g++-mp-4.6: 43.4
clang++: 40.6

Also, how do I compile with the clang/llvm XCode is using from the terminal? I can't find the command.

EDIT: The scores I output are "thousands of games per second" which开发者_C百科 are calculated over a long enough run of the program. Scores are very consistent over multiple runs, and recent major algorithmic improvements have given me 1% - 5% speed ups, for example. A 25% speed up of 40 to 50 is huge for my program.

UPDATE: I wasn't invoking clang++ from the command line with -flto. Now when I compare clang++ -O3 -flto to /Developer/usr/bin/clang++ -O3 -flto from the command line the results are closer, but the Apple one is still 6.5% faster.

Now how to enable link time optimization for gcc? When I try g++ -flto I get the following error:

cc1plus: error: LTO support has not been enabled in this configuration

Apple LLVM Compiler should be available under /Developer/usr/bin/clang.

I can't think of any particular reason why MacPorts clang++ would generate slower code... I would check whether you're passing in comparable command-line options. One thing that would make a large difference is if you're producing 32-bit code with one compiler, and 64-bit code with the other.

If GCC has no LTO then you need to build it yourself:

http://solarianprogrammer.com/2012/07/21/compiling-gcc-4-7-1-mac-osx-lion/

For LTO you need to add 'libelf' to the instructions.

http://sourceforge.net/apps/trac/mingw-w64/wiki/LTO%20and%20GCC

Exact speed of an algorithm can depend on all kinds of things that are totally out of your's and the compiler's power. You may have a loop where the execution time depends on precisely how the instructions are aligned in memory, in a way that the compiler couldn't predict. I have seen cases where a loop could enter different "states" with different execution times per iteration (so after a context switch, it could enter a state where it took either 12 or 13 cycles, rather randomly). This can all be coincidence.

And you might be using different libraries, which is quite possible the reason. In MacOS X, they are using a new and presumably faster implementation of std::string and std::vector, for example.