The logic is largely equivalent to the positive case all bit patterns that can result from adding two negative values will have the sign bit cleared if and only if an underflow occured.īy default, Java's int and long math silently wrap around on overflow and underflow. Thats what the left half (s & d & ~r) checks for the case where both arguments (s, d) are negative and a result that is positive. So the sign of the result again reveals the overflow condition. The most extreme value we can produce is MIN_VALUE + MIN_VALUE, which (again for byte example) shows that for any in range value (-1 to -128) the sign bit is set, while any possible overflowing value (-129 to -256) has the sign bit cleared. Now if both arguments are negative, their sum can never be closer to zero than any of the arguments, the sum must be closer to minus infinity. (~s & ~d & r) becomes true, only if, both operands (s, d) are positive and the result (r) is negative (the expression works on all 32 bits, but the only bit we're interested in is the topmost (sign) bit, which is checked against by the < 0). Thats exactly what the first (right) part of the expression checks: if (((s & d & ~r) | (~s & ~d & r)) < 0) Looking at the bit representations of all values that can result from adding two positive values, one finds that those that overflow (128 to 254) all have bit 7 set, while all that do not overflow (0 to 127) have bit 7 (topmost, sign) cleared. For a byte (example) that would mean 127 + 127 = 254. Now the maximum value that could result would be MAX_VALUE + MAX_VALUE (the extreme case both arguments are MAX_VALUE). You can check that beforehand as follows: public static boolean willAdditionOverflow(int left, int right) else if (result MAX_VALUE. If it underflows, it goes back to the maximum value and continues from there. If it overflows, it goes back to the minimum value and continues from there.

Java overflow error