Still unsure about signed integer overflow in C++

Question

In the following code I tested which form of overflow results in UB and causes therefore an hard error in a constexpr context:

#include <cstdint>
#include <limits>

using T = int8_t;
int main() {    
    constexpr bool b = []{
        T x = std::numeric_limits<T>::max();
        ++x; // GCC: UB, Clang: no UB
//        x += 1;
//        x = x + 1;
        return (x > std::numeric_limits<T>::max());
    }();

    return b;    
}

The preincrement gives an error (as I expected) for gcc but not for clang.

More strange is that the standard says that ++x is the same as x += 1, but using this gives no more an error on gcc (and clang as before).

And further x += 1 should be the same as x = x + 1, so the rhs is promoted to int and the result is implicitly converted. So, this should newer be UB.

So, the question is, which of the three statement really should be UB (I think only ++x) and which compiler is correct?

It's always UB. UB doesn't mean an error will occur, it just means literally what it says; the behavior of your program is undefined. That doesn't mean it's not allowed to work how you expect; it just means the compiler is under no obligation to produce an executable that does. — Kyle
– Kyle, Commented May 29, 2022 at 16:35
this isn't C. There's no C/C++ language. C and C++ are completely different languages — phuclv
– phuclv, Commented May 29, 2022 at 16:42
@wimalopaan Since c++20 x = x + 1 is well defined. x + 1 promoted to int first so no overflow happens and the assignment back to int8_t is now defined to work modulo 2^n. Whether that applies to x += 1 and ++x too I leave to the language lawyers. int8_t has been defined as two's-complement so the result of overflow should never be in question. It's silly C++ still calls it UB, stupid integer promotion breaking it all. — Goswin von Brederlow
– Goswin von Brederlow, Commented May 29, 2022 at 16:53
@GoswinvonBrederlow And pre-C++20 narrowing signed casts were implementation-defined (aka worked in practice), not UB. — HolyBlackCat
– HolyBlackCat, Commented May 29, 2022 at 16:54

Jeff Garrett · Accepted Answer · 2022-05-30 14:10:14Z

2

[expr.pre.incr]/1

The expression ++x is equivalent to x+=1.

[expr.ass]/6

The behavior of an expression of the form E1 op= E2 is equivalent to E1 = E1 op E2 except that E1 is evaluated only once.

But x = x + 1 is not UB (integer promotion and narrowing integer conversion), so the original is well-formed. Therefore, GCC is wrong.

answered May 30, 2022 at 14:10

Jeff Garrett

8,4801 gold badge22 silver badges19 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

wimalopaan Over a year ago

Well ok, then I will file a bug to gcc and see what the gcc people say.

Jeff Garrett Over a year ago

gcc.gnu.org/bugzilla/show_bug.cgi?id=105774

Jeff Garrett Over a year ago

Simultaneous thoughts.

Collectives™ on Stack Overflow

Still unsure about signed integer overflow in C++

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related