The following program calling a consteval function causes code to be emitted to compute the result of maxFoo() at runtime, when one would expect it to be computed at compile-time:

    $ cat <<EOF | clang++ -xc++ - -std=c++2a -Os -S -o a.s && cat a.s
    #include <array>
    #include <algorithm>

    struct Foo { int i; };
    static constexpr std::array<Foo, 3> foos = {{{1}, {2}, {3}}};

    static int consteval maxFoo() {
        auto it = std::max_element(foos.begin(), foos.end(), [](auto lhs, auto rhs) {
            return lhs.i < rhs.i;
        });

        return it->i;
    }

    int main() { return maxFoo(); }
    EOF

Here's a few interesting observations:
1. This only happens when -Os or -O1 are used.
2. Even slight modifications of the above code will cause it to be inlined, for example implementing `maxFoo()` equivalently but in a single expression.
3. The same issue happens whether `consteval` is used or not (which leads me to think this is a codegen issue, not a front-end issue).

Godbolt link: https://godbolt.org/z/MA9U8b

After playing around and debugging Clang for a bit, I am fairly confident that this is not a bug per-se, but only an important QOI issue. In particular, I think Clang behaves correctly with respect to the Standard, which only says about immediate functions (http://eel.is/c++draft/expr.const#13):

    > [...] An expression or conversion is an immediate invocation if 
    > it is a potentially-evaluated explicit or implicit invocation of 
    > an immediate function and is not in an immediate function context. 
    > An immediate invocation shall be a constant expression.

This doesn't talk about codegen, since the Standard doesn't have such a notion. Also, Clang does treat `maxFoo()` as a constant expression, and in fact the front-end even calculates the result properly in an APValue -- so Clang is *correct* as far as the Standard is concerned.

However, the code generation appears to never be passed that knowledge, and as a result it can sometimes fail to fold the immediate call, depending on optimization levels. Since the intent of consteval was *specifically* to make sure that no code is generated for such calls, I would argue this is an important QOI issue (if we're being pedantic), and straight up a bug (as far as 99% of users are concerned).