1 << 31 cannot be represented by type 'int'?

Question

Why does -fsanitize=undefined throw

runtime error: left shift of 1 by 31 places cannot be represented in type 'int'

on this code

uint32_t z;
z = 1 << 31;

?

Lynn

Shifting into (or beyond) the sign bit is undefined behavior. While z is uint32_t, 1 is a plain old int, which is signed (and not necessarily 32 bits wide). – Dedifferentiation

Answer 1

Make the 1 unsigned:

uint32_t z;
z = UINT32_C(1) << 31;

Lynn

That's not guaranteed to work. 1u is of type unsigned int, which is not guaranteed to be wider than 16 bits. You say you need to cast it, but then you don't cast it. You can do unsigned uint32_t z = (uint32_t)1 << 31; – Susansusana

Better to use a constant literal of the correct type than cast: UINT32_C(1) << 31 – Scissile

@ChrisDodd What issues could casting present? – Lynn

The cast will be constant-folded away so has no extra cost (except when optimization is completely disabled), but occasionally causes precedence confusion. Using static_cast<.. can avoid the latter, but is C++ only and more verbose. The constant literal ensures that it is really constant. – Scissile

Answer 2

Because a left shift of 1 by 31 places cannot be represented in type int.

Mathematically, 1 << 31 is 2³¹, or 2147483648. INT_MAX on a typical system (where int is 32 bits) is one less than that, or 2147483647. If an arithmetic operation on a signed type overflows (yields a result outside the result of the type), the behavior is undefined. (Don't assume it will wrap around. It might, but the language doesn't guarantee it.)

If you need a type that can represent that value, you can use an unsigned type that's at least 32 bits wide, or a signed type that's more than 32 bits wide. unsigned long or long long is guaranteed to be that wide. (The language doesn't guarantee that int is more than 16 bits wide, but it's likely to be 32 on most systems.)

Susansusana