constexpr instances of class that usually have non-constexpr behavior in the destructor, in C++20

I would like to be able to create constexpr values for a type that usually has a non-trivial destructor. Unfortunately, I'm using C++20, so don't have if consteval. Here is a minimal working example that is accepted by gcc 12.2.1 and clang++ 15.0.7, but I'm not sure if it's legal:

#include <type_traits>
#include <string.h>

struct secret {
  int value_;
  constexpr secret(int value) : value_(value) {}
  constexpr ~secret() {
    if (!std::is_constant_evaluated())
      explicit_bzero(&value_, sizeof(value_));
  }
};

constexpr secret my_secret = 5;
secret my_destroyed_secret = 6;

My questions are:

1. Is it legal to call a function like explicit_bzero from within a constexpr destructor? Since the if in the destructor is not constexpr, it seems like it should be illegal.
2. If it is legal, then why?
3. If it is not legal, then is there any other way to accomplish why I want--basically clobber any destroyed value that wasn't constexpr constructed?

> Is this code legal? Since the if in the destructor is not constexpr, it seems like it should be illegal.

> If it is legal, then why?

Yes, it is. Using std::is_constant_evaluated without constexpr in an if is the only correct way to use it.

It is supposed to tell you whether the evaluation of std::is_constant_evaluated() (and the expression containing it) is part of evaluation as a constant expression (i.e. compile-time evaluated expression) or not. If you call it inside a condition of a if constexpr then it is always evaluated as constant expression and can only ever be true, because the condition of if constexpr is required to be in itself a constant expression, regardless of whether or not the whole if statement is evaluated as part of another constant expression.

That this seems to confuse people is one of the reasons that if consteval was introduced in C++23 to replace std::is_constant_evaluated. See the paper which proposed if consteval for C++23.