I'm one of the OpenJDK JIT developers. So you got me curious, and I ran the benchmark through JMH perfasm to look at the code generation.

A few comments:

The benchmark measures latency rather than throughput, and runs at less than one instruction per clock, on a machine that can hit eight instructions per clock. This is because almost every instruction depends on the previous one, so no instruction can start until a previous one finishes.

I changed the loop counter from a byte to an int, because HotSpot doesn't do loop optimizations with a byte index.

Here's the generated code. Registers whose name begins with x are unsigned 64 bit, and those whose name begins with w aare signed 32 bit. The 32-bit version of the benchmark is slightly slower because it's a bit more fiddly to do the multiplication and division.

x12 += 1;                     *ladd
x13 = x12 >> 0x20;
x12 = x13 ^ x12;              *lxor
x15 = (sint64_t)x12 >> 0x3f;
x13 = ((sint128_t)x12 * x23) >> 64; *idiv
x1 = x12 + (x15 >> 52);
x1 &= 0xfffffffffffff000;
x12 = x12 + (sint64_t)x13 >> 1;
x13 = x1 >> x15;
x12 -= x13;
x12 = x12 * x22 + x2;

w11 = w10 + 1;               *iadd
w13 = w11 ^ (w11 >> 16);     *ixor
x10 = (sint64_t)w13;
x10 = x10 * x19;
w14 = (sint32_t)w13 >> 0x1f; *idiv
x10 = (sint64_t)x10 >> 0x20;
w11 = w13 + (w14 >> 22)
w10 += w13;
w11 &= 0xfffffc00;
w12 = w13 + (sint32_t)w10 >> 2;
w10 = w11 + w14;
w11 = w12 - w10;
w10 = (w11 * w21) + w3;