Question

I saw some code (in arc4random.c of libbsd) calculating 2**32 % x. A cleaned up version is below:

uint32_t x;
...
if (x >= 2) {
    /* Calculate (2**32 % x) avoiding 64-bit math */
    if (x > 0x80000000)
        mod_res = 1 + ~x;       /* 2**32 - x */
    else {
        /* (2**32 - (x * 2)) % x == 2**32 % x when x <= 2**31 */
        mod_res = ((0xffffffff - (x * 2)) + 1) % x;
    }
}

While the reasoning makes sense, my question is whether are there some obscure reasons not to use a simpler:

uint32_t x;
...
if (x >= 2) {
    /* Calculate (2**32 % x) avoiding 64-bit math */
    mod_res = -x % x;
}

Answer 1

Your code won’t work on a machine where int is larger than 32 bits. In this case, in the expression -x, the operand would be promoted to int type, and thus become signed. This would cause the result of the expression -x % x to always be zero.

This behavior is due to C’s integer promotion rules, which state that if an int can represent all values of an operand, then that operand will be promoted to an int. While this always preserves value, it may change the signedness of the type.

On a compiler with 32-bit ints it would work correctly, because unsigned int would not be promoted to int, and so -x would be equal to 2**32 - x.

Your version can be fixed by casting the promoted value back to unsigned:

mod_res = ((uint32_t) -x) % x;

Here is an example demonstrating this with a 16-bit type on a machine with 32-bit ints.