template <typename T>
constexpr int my_log2(T n)
{
    return n? 1+my_log2(n>>1): -1;
}

int main()
{
    return my_log2<unsigned>(42);
}

template <int I> struct eval_im
{
    enum { value = I };
};

ДФ>template <typename T>
ДФ>constexpr int my_log2(T n)
ДФ>{
ДФ>    return n? 1+my_log2(n>>1): -1;
ДФ>}

ДФ>int main()
ДФ>{
ДФ>    return my_log2<unsigned>(42);
ДФ>}
ДФ>

int main()
{
    constexpr auto rrr = my_log2<unsigned>(42);
    return rrr;
}

; Listing generated by Microsoft (R) Optimizing Compiler Version 19.11.25325.0 

    TITLE    c:\projects\vc2017\log2\log2.cpp
    .686P
    .XMM
    include listing.inc
    .model    flat

INCLUDELIB OLDNAMES

EXTRN    @__security_check_cookie@4:PROC
PUBLIC    ??$my_log2@I@@YAHI@Z                ; my_log2<unsigned int>
PUBLIC    _main
; Function compile flags: /Ogtp
;    COMDAT _main
_TEXT    SEGMENT
_main    PROC                        ; COMDAT
; File c:\projects\vc2017\log2\log2.cpp
; Line 6
    mov    ecx, 21                    ; 00000015H
    call    ??$my_log2@I@@YAHI@Z            ; my_log2<unsigned int>
    inc    eax
; Line 44
    ret    0
_main    ENDP
_TEXT    ENDS
; Function compile flags: /Ogtp
;    COMDAT ??$my_log2@I@@YAHI@Z
_TEXT    SEGMENT
??$my_log2@I@@YAHI@Z PROC                ; my_log2<unsigned int>, COMDAT
; _n$ = ecx
; File c:\projects\vc2017\log2\log2.cpp
; Line 6
    test    ecx, ecx
    je    SHORT $LN3@my_log2
    shr    ecx, 1
    call    ??$my_log2@I@@YAHI@Z            ; my_log2<unsigned int>
    inc    eax
; Line 7
    ret    0
$LN3@my_log2:
; Line 6
    or    eax, -1
; Line 7
    ret    0
??$my_log2@I@@YAHI@Z ENDP                ; my_log2<unsigned int>
_TEXT    ENDS
END

C>int main()
C>{
C>    constexpr auto rrr = my_log2<unsigned>(42);
C>    return rrr;
C>}
C>

_TEXT    SEGMENT
_main    PROC                        ; COMDAT
; File c:\projects\vc2017\log2\log2.cpp
; Line 44
    mov    eax, 5
; Line 45
    ret    0
_main    ENDP

clang -O1: run time
clang -O2: compile time
gcc -O0: run time
gcc -O1: compile time
gcc -O2: compile time

The correct answer — as stated by Herb — is that according to the standard a constexpr function may be evaluated at compiler time or run time unless it is used as a constant expression, in which case it must be evaluated at compile-time. To guarantee compile-time evaluation, we must either use it where a constant expression is required (e.g., as an array bound or as a case label) or use it to initialize a constexpr. I would hope that no self-respecting compiler would miss the optimization opportunity to do what I originally said: "A constexpr function is evaluated at compile time if all its arguments are constant expressions."

template <typename T>
    constexpr int my_log2(T n)
{
    if (n <= 0)
        std::terminate();
    if (n == 1)
        return 0;
    return 1 + my_log2(n >> 1);
}

int main()
{
    constexpr int x = my_log2(42);
    constexpr int y = my_log2(0);
    std::cout << x << std::endl;
}

mov     eax, 5
ret

#include <exception>

template <typename T>
    constexpr int my_log2(T n)
{
    if (n <= 0)
        std::terminate();
    if (n == 1)
        return 0;
    return 1 + my_log2(n >> 1);
}

int main()
{
    constexpr int x = my_log2(42);
    using t = char[my_log2(43)];
    return x + sizeof(t);
}

#include <exception>

template <typename T>
    int my_log2(T n)
{
    if (n <= 0)
        std::terminate();
    if (n == 1)
        return 0;
    return 1 + my_log2(n >> 1);
}

int main()
{
    int x = my_log2(42);
    auto sizeof_t = my_log2(43);
    return x + sizeof_t;
}

    constexpr int x = my_log2(42);
    using t = char[my_log2(43)];
    return x + sizeof(t);

A conditional-expression is a core constant expression unless it involves one of the following as a potentially evaluated subexpression (3.2), but subexpressions of logical AND (5.14), logical OR (5.15), and conditional (5.16) operations that are not evaluated are not considered [ Note: An overloaded operator invokes a function.—end note ]:

A conditional-expression e is a core constant expression unless the evaluation of e, following the rules of the abstract machine (1.9), would evaluate one of the following expressions:

Произошла типичная подмена понятий.
Добро победит в отдалённой перспективе.
А пока бери, сынок, шашку и рубай всю эту сволочь направо и налево!

#include <iostream>

using ull = unsigned long long;
using cull = const ull;

constexpr ull fact(cull x)
{
    return x ? x * fact(x - 1) : 1;
}

int main()
{
    std::cout << fact(5) << std::endl;
}

T>Ok, для тех, кто в танке:

1. С опцией -Ofast вместо вызова функции подставляется число 120.
2. Без данной опции генерится вызов функции.