Q:

Why is clang not computing fibonacci(500) with a constexpr version of fibonacci?

I was trying things with constexpr:
#include <iostream>

constexpr long long fibonacci(const int x)
{
    return x <= 1 ? 1 : fibonacci(x - 1) + fibonacci(x - 2);
}

int main()
{
    const long long lol = fibonacci(500);
    std::cout << lol << std::endl;
}

So I want lol to be computed at compile time:
toogy@stewie
» g++ -std=c++14 -g src/test.cc -o test.out
toogy@stewie
» ./test.out 
4859788740867454402

It's working really well with g++. At compilation it's even doing some memoization, optimizing this crappy fibonnaci function and then computing fibonacci(500) instantly.
Then I try with clang++:
toogy@stewie
» clang++ -std=c++1y -g src/test.cc -o test.out 
toogy@stewie
» ./test.out
... very long

lol is not computed at compile time by clang++ (proved by gdb). Why?

A:

It hits clang's maximum recursion depth. You can force lol to be evaluated at compile time by making it constexpr, i.e.:
constexpr long long lol = fibonacci(500);

Doing that and compiling with clang++ -std=c++11 t.cpp gives the errors:
t.cpp:10:25: error: constexpr variable 'lol' must be initialized by a constant
      expression
    constexpr long long lol = fib(500);
                        ^     ~~~~~~~~
t.cpp:4:1: note: constexpr evaluation hit maximum step limit; possible infinite
      loop?
{
^
t.cpp:5:38: note: in call to 'fib(4)'
    return x <= 1 ? 1 : fib(x - 1) + fib(x - 2);
                                     ^
t.cpp:5:25: note: in call to 'fib(6)'
    return x <= 1 ? 1 : fib(x - 1) + fib(x - 2);
                        ^
t.cpp:5:38: note: in call to 'fib(7)'
    return x <= 1 ? 1 : fib(x - 1) + fib(x - 2);
                                     ^
t.cpp:5:25: note: in call to 'fib(9)'
    return x <= 1 ? 1 : fib(x - 1) + fib(x - 2);
                        ^
t.cpp:5:25: note: in call to 'fib(10)'
t.cpp:5:25: note: (skipping 480 calls in backtrace; use
      -fconstexpr-backtrace-limit=0 to see all)
t.cpp:5:25: note: in call to 'fib(496)'
t.cpp:5:25: note: in call to 'fib(497)'
t.cpp:5:25: note: in call to 'fib(498)'
t.cpp:5:25: note: in call to 'fib(499)'
t.cpp:10:31: note: in call to 'fib(500)'
    constexpr long long lol = fib(500);
                              ^
1 error generated.

Clang can't (with default compiler flags; though I still couldn't get it to compile with -fconstexpr-depth=1000000000 (that's 1 billion)) evaluate fibonacci(500) at compile time, so it instead does it at runtime with the code you've posted. As @Streppel links to, you can increase the maximum recursion depth for constant expressions using the -fconstexpr-depth=N compiler flag.
However, the 500th fibonacci number is huge*, so this will certainly overflow, which is undefined behavior for signed integers (so all bets are off, really). (But you can do it if you use template metaprogramming)
*as in 105 digits huge: 139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125

