`<numeric>`: `gcd` and `lcm` do not check for negative overflow in compile time

[AlexGuteniev]

Describe the bug
When given the least possible signed integer value, gcd cannot make it positive, and returns a negative result.
According to [numeric.ops.gcd]/2, it is UB:

Preconditions: |m| and |n| are representable as a value of common_­type_­t<M, N>.
[Note 1: These requirements ensure, for example, that gcd(m, m)=|m| is representable as a value of type M. — end note]

According to [expr.const]/6 whereas language UB shouldn't compile, it is implementation-specific if library precondition violation compiles in constexpr context or not.

Since we are permitted do a favor and reject overflowing value, we should.

The same is for lcm, except that it should also check the result.

Command-line test case

#include <limits>
#include <numeric>
using namespace std;

auto test() {
    constexpr int x = numeric_limits<int>::lowest();
    constexpr int y = numeric_limits<int>::lowest();
    constexpr auto z = std::gcd(x, y);
    return z;
}

returns -1

Expected behavior
Don't compile

STL version

Version 17.0.0 Preview 6.0

Additional context
From this conversation https://discord.com/channels/737189251069771789/740318951766098012/902077925506039808

[frederick-vs-ja]

Sadly MSVC apparently doesn't check arithmetic overflow in constant evaluation, so non-trivial works may be needed even for gcd, e.g. __builtin_is_constant_evaluated and a non-constexpr function (may be needed for lcm even if there's no such bug, as the cheking needs an addition division).

---

By the way, can we make a call to gcd well-defined de jure whenever the mathematical result is representable?

For example, implementations may be enforced to write something like this:

if constexpr (is_signed_v<_Common>) {
    if (_Mx == numeric_limits<_Common>::lowest())
        return static_cast<_Common>(_Nx) & -static_cast<_Common>(_Nx);
    if (_Nx == numeric_limits<_Common>::lowest())
        return static_cast<_Common>(_Mx) & -static_cast<_Common>(_Mx);
}

Casey Carter (@CaseyCarter) W-E-Brown

[AlexGuteniev]

Sadly MSVC apparently doesn't check arithmetic overflow in constant evaluation

Good point, we may want wait for DevCom-1202945 to be fixed.

__builtin_is_constant_evaluated

I don't think builtin should be used directly, rather we may want to limit the check to _HAS_CXX20 and use the standard is_constant_evaluated.

[AlexGuteniev]

By the way, can we make a call to gcd well-defined de jure whenever the mathematical result is representable?

Why do you want that?

For example, implementations may be enforced to write something like this

We might not even need to special case it. Just cast to the corresponding unsigned and do as usual.

[AlexGuteniev]

By the way, can we make a call to gcd well-defined de jure whenever the mathematical result is representable?

Why do you want that?

Now I see that it could be more convenient to limit UB cases only to non-representable result, but on the other hand the standard wording would be a bit longer and more confusing.