1. The compiler should fail and produce a helpful error.
   
2. The compiler should produce a warning
   
3. The compiler should crash and burn horribly
   

• The compiler should "helpfully" alter my code to do something else (such as evaluating at runtime instead)
  

#include <cstdio>
#include <cstdint>
#include <cinttypes>

constexpr int64_t compute(int64_t x) {
    int64_t result = 0;
    while (result < (10000 * x)) {
        result += 1;
    }
    return result;
}

enum MyEnum: int64_t {
    foo = compute(5),
    bar = compute(10)
};

int main() {
    printf("%" PRId64 "%" PRId64 "%" PRId64 "\n", foo, bar, compute(90000000));
}

• Change the value of the bar enum to be compute(90000000) and observe that the compiler fails because it can't do that compile-time computation in the allotted number of compile-time steps (this is basically the "desired infinite hang" case, except not ridiculously hostile to the user or impossible to debug).
  
• Change -O1 to -O2 and observe that it actually does not emit a call compute() at all and in fact pre-computes the very same value that failed above. So even though you can't force it to be computed at compile-time, it is allowed to do so as an optimization, even if doing so would exceed the limit for doing it in a compile-time context. This is probably the behaviour that's being described as "the compiler gave up and computed it at runtime instead".

Volte fucked around with this message at 15:05 on Mar 25, 2019

Volte fucked around with this message at 15:45 on Mar 25, 2019