Can I overflow uint32_t in a temporary result?

Question

Basically what happens on a 32bit system when I do this:

uint32_t test (void)
{
  uint32_t myInt;

  myInt = ((0xFFFFFFFF * 0xFFFFFFFF) % 256u );

  return myInt;
}

Answer 1

Let's assume that int is 32 bits.

1. 0xFFFFFFFF will have type unsigned int. There are special rules that explain this, but because it is a hexadecimal constant and it doesn't fit in int, but does fit in unsigned int, it ends up as unsigned int.

2. 0xFFFFFFFF * 0xFFFFFFFF will first go through the usual arithmetic conversions, but since both sides are unsigned int, nothing happens. The result of the multiplication is 0xfffffffe00000001 which is reduced to unsigned int by using the modulo 2³² value, resulting in the value 1 with type unsigned int.

3. (unsigned int)1 % 256u is equal to 1 and has type unsigned int. Usual arithmetic conversions apply here too, but again, both operands are unsigned int so nothing happens.

4. The result is converted to uint32_t, but it's already unsigned int which has the same range.

However, let's instead suppose that int is 64 bits.

1. 0xFFFFFFFF will have type int.

2. 0xFFFFFFFF * 0xFFFFFFFF will overflow! This is undefined behavior. At this point we stop trying to figure out what the program does, because it could do anything. Maybe the compiler would decide not to emit code for this function, or something equally absurd.

This would happen in a so-called "ILP64" or "SILP64" architecture. These architectures are rare but they do exist. We can avoid these portability problems by using 0xFFFFFFFFu.