RFR: 8318966: Some methods make promises about Java array element alignment that are too strong

[Maurizio Cimadamore]

On Thu, 16 Nov 2023 17:34:40 GMT, Paul Sandoz <psandoz at openjdk.org> wrote:

>> See the JBS issue for an extended problem description.
>> 
>> This patch changes the specification and implementation of `MethodHandles::byteArrayViewVarHandle`, `MethodHandles::byteBufferViewVarHandle`, `ByteBuffer::alignedSlice`, and `ByteBuffer::alignmentOffset` to weaken the guarantees they make about the alignment of Java array elements, in order to bring them in line with the guarantees made by an arbitrary JVM implementation (which makes no guarantees about array element alignment beyond them being aligned to their natural alignment).
>> 
>> - `MethodHandles::byteArrayViewVarHandle`: we can not guarantee any alignment for the accesses. Which means we can only reliably support plain get and set access modes. The javadoc text explaining which other access modes are supported, or how to compute aligned offsets into the array is dropped, as it is not guaranteed to be correct on all JVM implementations. The implementation of the returned VarHandle is changed to throw an `UnsupportedOperationException` for the unsupported access modes, as mandated by the spec of `VarHandle` [1].
>> 
>> - `MethodHandles::byteBufferViewVarHandle`: the implementation/spec is incorrect when accessing a heap buffer (wrapping a byte[]), for the same reasons as `byteArrayViewVarHandle`. The spec is changed to specify that when accessing a _heap buffer_, only plain get and set access modes are supported. The implementation of the returned var handle is changed to throw an `IllegalStateException` when an access is attempted on a heap buffer using an access mode other than plain get or set. Note that we don't throw an outright `UnsupportedOperationException` for this case, since whether the access modes are supported depends on the byte buffer instance being used.
>> 
>> - `ByteBuffer::alignedSlice` and `ByteBuffer::alignmentOffset`: The former method depends directly on the latter for all its alignment computations. We change the implementation of the latter method to throw an `UnsupportedOperationException` for all unit sizes greater than 1, when the buffer is non-direct. This change is largely covered by the existing specification:
>> 
>> 
>>      * @throws UnsupportedOperationException
>>      *         If the native platform does not guarantee stable alignment offset
>>      *         values for the given unit size when managing the memory regions
>>      *         of buffers of the same kind as this buffer (direct or
>>      *         non-direct).  For example, if garbage collection would...
>
> src/java.base/share/classes/java/lang/invoke/MethodHandles.java line 4610:
> 
>> 4608:      * {@link Double#doubleToRawLongBits}, respectively).
>> 4609:      * <p>
>> 4610:      * Access to heap byte buffers is always unaligned.
> 
> I recommend merging that sentence into the paragraph on heap byte buffers e.g.:
>> For direct buffers, access of the bytes at an index is always misaligned. As a result only the plain...

But... surely if I'm just accessing bytes the access cannot possibly be mis-aligned?

-------------

PR Review Comment: https://git.openjdk.org/jdk/pull/16681#discussion_r1396191981