constexpr и вычисления времени компиляции

constexpr int square(int x) { return x * x; }
int runtime_value();
int a = square(runtime_value());
constexpr int b = square(4);

#include <iostream>
constexpr int double_value(int x){ return x*2; }
int main(){ int x; std::cin >> x; std::cout << double_value(x); }

int runtime();
constexpr int x = runtime();

constexpr int sum_to(int n) {
    int sum = 0;
    for (int i = 1; i <= n; ++i)
        sum += i;
    return sum;
}
static_assert(sum_to(10) == 55);

constexpr int make_value() {
    int* p = new int(7);
    int result = *p;
    delete p;
    return result;
}

static_assert(make_value() == 7);

constexpr int checked_square(int x) { return x * x; }
consteval int compile_time_id(int x) { return x * 31 + 7; }

int a = checked_square(read_value());
constexpr int b = compile_time_id(5);

consteval int square(int x){ return x*x; }
int n; std::cin >> n;
int y = square(n);

constexpr int checked_abs(int x) {
    if consteval {
        if (x == std::numeric_limits<int>::min())
            throw "overflow";
    }
    return x < 0 ? -x : x;
}

consteval int token(int n) { return n + 100; }
// попытка использовать адрес как обычный runtime callback
auto* callback = &token;

consteval std::uint32_t field_id(std::string_view name) {
    return checked_hash(name); // ошибка компиляции при недопустимом имени
}
constexpr auto id = field_id("user.name");

template<class T>
std::string describe(const T& value) {
    if constexpr (std::integral<T>) {
        return std::to_string(value);
    } else {
        return value.to_string();
    }
}

using Five = std::integral_constant<int, 5>;

static_assert(Five::value == 5);
static_assert(std::is_same_v<Five::value_type, int>);
int data[Five{}];

template<class... Args>
auto sum(Args... args) {
    return (args + ... + 0);
}

static_assert(sum(1, 2, 3) == 6);

std::array<int, 4> fixed{};
std::array<int, 8> larger{};
static_assert(!std::is_same_v<decltype(fixed), decltype(larger)>);

std::vector<int> a(4), b(8);
static_assert(std::is_same_v<decltype(a), decltype(b)>);

template<class T>
struct add_pointer_if_scalar {
    using type = std::conditional_t<std::is_scalar_v<T>, T*, T>;
};
using Result = add_pointer_if_scalar<int>::type;

template<int N>
struct Depth : Depth<N - 1> {};
template<>
struct Depth<0> {};
Depth<100000> object;

constexpr std::uint64_t search() {
    for (std::uint64_t i = 0; i < 1'000'000'000ULL; ++i)
        if (matches(i)) return i;
    return 0;
}
constexpr auto value = search();

consteval std::uint32_t build_stamp() {
    return parse_hhmmss(__TIME__);
}

inline constexpr auto stamp = build_stamp();
// Два запуска компилятора в разное время дают разные объекты.