On Thu, 16 Nov 2023 17:34:40 GMT, Paul Sandoz <psan...@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
