I've been using XCode for a while now (doing iOS versions of our games...), and I wouldn't exactly describe the switch from gcc to llvm as a positive one. Granted, some of the problem is that XCode wasn't very good to start with and gets worse with every version, but some of it is definitely llvm as well.
One of the things I keep hearing about llvm is that the error reporting is supposed to be top notch; it's supposed to be really good at pinpointing the actual error instead of pointing to wherever the compiler finally gave up.
Sadly, in practice, llvm is the worst compiler I've worked with for errors since... well, the early 90s, at least. I've had a typo in a variable name in a single location generate a cascade of hundreds of errors, *none* of which referenced the actual syntax error. Leave out a semicolon by accident and you'll see an error cascade. Put 1,0f instead of 1.0f, error cascade.
Somehow none of these trip up gcc at all.
Debugging was a lot more reliable under gcc as well. Since the llvm switch, two times out of three trying to watch a variable brings XCode down in flames.
Code generation seems no better (our games take the same amount of time to build, roughly, and we've seen no measurable performance difference in the games), and we haven't noticed much else different except for the occasional llvm crash.
Perhaps it's better when it isn't running on OSX, but personally I'm filing llvm under "lots of potential, needs to mature".