|
When targeting x86, we opt not to use a helper call to implement the
64-bit unsigned modulus operator if we have a tree of either of the
following forms:
- `(umod ulong (x ulong) (cast ulong (const int const_val)))`
- `(umod ulong (x ulong) (const ulong const_val))`
where `const_val` falls in the range `[2, 0x3fffffff]`.
We eventually decompose this into `(umod uint (gt_long lo hi) (const int const_val))`.
This was then emitted as:
mov eax, lo
mov edx, hi
mov reg, const_val
div edx:eax reg
Unfortunately, this generated code does not take into account the fact
that the result of the modulus may not fit into 32 bits. This can cause
an overflow exception at runtime despite the fact that the modulus
originally produced a 64-bit result.
This change fixes the code generation to check for overflow before
performing the modulus and perform a 64-bit division if the result would
overflow. This results in generated code like the following:
mov eax, lo
mov edx, hi
mov reg, const_val
cmp edx, reg
jb noOverflow
mov temp, eax
mov edx, eax
xor edx, edx
div edx:eax, const_val
mov eax, temp
noOverflow:
div edx:eax, const_val
Which is identical to the code produced by JIT32 and the legacy backend.
|
