On Tue, 7 Jul 2026 10:09:48 GMT, Kuai Wei <[email protected]> wrote:
>> I recently noticed a behavioral discrepancy in
>> jdk.internal.util.ArraysSupport.vectorizedMismatch between the Java
>> implementation and the platform intrinsic implementations.
>>
>> Current behavior
>>
>> The Java implementation may leave a tail of elements unchecked, returning
>> the bitwise complement of the number of remaining elements (i.e.,
>> ~remaining).
>> The x86_64 intrinsic, by contrast, compares all elements and simply returns
>> -1 when no mismatch is found.
>> Because of this inconsistency, every caller has to handle the "remaining
>> elements" case defensively:
>>
>>
>> int i = vectorizedMismatch(...);
>> if (i >= 0) {
>> return i; // mismatch found
>> } else {
>> length -= ~i; // fall through to handle remaining elements
>> }
>>
>> Proposed change
>>
>> This PR refines the Java implementation so that it always compares all
>> elements and returns -1 when no mismatch is found, matching the x86_64
>> intrinsic behavior. This also simplify all callsite because it eliminates
>> the need for callers to handle remaining elements.
>>
>> A regression test is included at
>> `test/hotspot/jtreg/compiler/intrinsics/VectorizedMismatchReturnDiffTest.java`
>> which demonstrates the original behavioral difference.
>>
>> ## Test
>> - [x] tier1 test suites on linux x86_64
>> - [x] tier1 test suites on linux aarch64
>>
>> ---------
>> - [x] I confirm that I make this contribution in accordance with the
>> [OpenJDK Interim AI Policy](https://openjdk.org/legal/ai).
>
> Kuai Wei has updated the pull request incrementally with one additional
> commit since the last revision:
>
> recover some comments
The call sites I modified are within the OpenJDK codebase itself, so they can
be updated in the same PR to match the new spec.
To clarify the compatibility concern, here's the typical pattern for old spec:
int i = vectorizedMismatch(...);
if (i >= 0) {
return i; // mismatch found
} else {
i = length - ~i;
}
for (; i < length; i++) {
if (a[i] != b[i])
return i;
}
return -1; // no mismatch
Under the new behavior, vectorizedMismatch returns -1. This gives i = length -
~(-1) = length, so the `for` loop condition `i < length` is immediately false
and the loop body is skipped. In other words, existing call sites that follow
the old spec continue to work correctly — the tail loop becomes a no-op.
-------------
PR Comment: https://git.openjdk.org/jdk/pull/31802#issuecomment-4911006550
