--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/classes/java/lang/invoke/X-VarHandleByteArrayView.java.template Thu Mar 24 11:21:21 2016 +0100
@@ -0,0 +1,497 @@
+/*
+ * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.lang.invoke;
+
+import jdk.internal.misc.Unsafe;
+import jdk.internal.vm.annotation.ForceInline;
+
+import java.nio.ByteBuffer;
+import java.nio.ReadOnlyBufferException;
+import java.util.Objects;
+
+import static java.lang.invoke.MethodHandleStatics.UNSAFE;
+
+#warn
+
+final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase {
+
+ static final int ALIGN = $BoxType$.BYTES - 1;
+
+#if[floatingPoint]
+ @ForceInline
+ static $rawType$ convEndian(boolean big, $type$ v) {
+ $rawType$ rv = $Type$.$type$ToRaw$RawType$Bits(v);
+ return big == BE ? rv : $RawBoxType$.reverseBytes(rv);
+ }
+
+ @ForceInline
+ static $type$ convEndian(boolean big, $rawType$ rv) {
+ rv = big == BE ? rv : $RawBoxType$.reverseBytes(rv);
+ return $Type$.$rawType$BitsTo$Type$(rv);
+ }
+#else[floatingPoint]
+ @ForceInline
+ static $type$ convEndian(boolean big, $type$ n) {
+ return big == BE ? n : $BoxType$.reverseBytes(n);
+ }
+#end[floatingPoint]
+
+
+ private static class ByteArrayViewVarHandle extends VarHandle {
+ final boolean be;
+
+ ByteArrayViewVarHandle(Class<? extends ByteArrayViewVarHandle> implSubType,
+ Class<?> arrayType, Class<?> component, boolean be) {
+ super(VarForm.createFromStatic(implSubType),
+ arrayType, component, int.class);
+ this.be = be;
+ }
+ }
+
+ static final class ArrayHandle extends ByteArrayViewVarHandle {
+
+ ArrayHandle(boolean be) {
+ super(ArrayHandle.class, byte[].class, $type$.class, be);
+ }
+
+ @ForceInline
+ static int index(byte[] ba, int index) {
+ return Objects.checkIndex(index, ba.length - ALIGN, null);
+ }
+
+ @ForceInline
+ static long address(byte[] ba, int index) {
+ long address = ((long) index) + Unsafe.ARRAY_BYTE_BASE_OFFSET;
+ if ((address & ALIGN) != 0)
+ throw newIllegalStateExceptionForMisalignedAccess(index);
+ return address;
+ }
+
+ @ForceInline
+ static $type$ get(ArrayHandle handle, Object oba, int index) {
+ byte[] ba = (byte[]) oba;
+#if[floatingPoint]
+ $rawType$ rawValue = UNSAFE.get$RawType$Unaligned(
+ ba,
+ ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
+ handle.be);
+ return $Type$.$rawType$BitsTo$Type$(rawValue);
+#else[floatingPoint]
+ return UNSAFE.get$Type$Unaligned(
+ ba,
+ ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
+ handle.be);
+#end[floatingPoint]
+ }
+
+ @ForceInline
+ static void set(ArrayHandle handle, Object oba, int index, $type$ value) {
+ byte[] ba = (byte[]) oba;
+#if[floatingPoint]
+ UNSAFE.put$RawType$Unaligned(
+ ba,
+ ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
+ $Type$.$type$ToRaw$RawType$Bits(value),
+ handle.be);
+#else[floatingPoint]
+ UNSAFE.put$RawType$Unaligned(
+ ba,
+ ((long) index(ba, index)) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
+ value,
+ handle.be);
+#end[floatingPoint]
+ }
+
+ @ForceInline
+ static $type$ getVolatile(ArrayHandle handle, Object oba, int index) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.get$RawType$Volatile(
+ ba,
+ address(ba, index(ba, index))));
+ }
+
+ @ForceInline
+ static void setVolatile(ArrayHandle handle, Object oba, int index, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ UNSAFE.put$RawType$Volatile(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ getAcquire(ArrayHandle handle, Object oba, int index) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.get$RawType$Acquire(
+ ba,
+ address(ba, index(ba, index))));
+ }
+
+ @ForceInline
+ static void setRelease(ArrayHandle handle, Object oba, int index, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ UNSAFE.put$RawType$Release(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ getOpaque(ArrayHandle handle, Object oba, int index) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.get$RawType$Opaque(
+ ba,
+ address(ba, index(ba, index))));
+ }
+
+ @ForceInline
+ static void setOpaque(ArrayHandle handle, Object oba, int index, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ UNSAFE.put$RawType$Opaque(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, value));
+ }
+#if[CAS]
+
+ @ForceInline
+ static boolean compareAndSet(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return UNSAFE.compareAndSwap$RawType$(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ compareAndExchangeVolatile(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.compareAndExchange$RawType$Volatile(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static $type$ compareAndExchangeAcquire(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.compareAndExchange$RawType$Acquire(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static $type$ compareAndExchangeRelease(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.compareAndExchange$RawType$Release(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static boolean weakCompareAndSet(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return UNSAFE.weakCompareAndSwap$RawType$(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static boolean weakCompareAndSetAcquire(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return UNSAFE.weakCompareAndSwap$RawType$Acquire(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static boolean weakCompareAndSetRelease(ArrayHandle handle, Object oba, int index, $type$ expected, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return UNSAFE.weakCompareAndSwap$RawType$Release(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ getAndSet(ArrayHandle handle, Object oba, int index, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.getAndSet$RawType$(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, value)));
+ }
+#end[CAS]
+#if[AtomicAdd]
+
+ @ForceInline
+ static $type$ getAndAdd(ArrayHandle handle, Object oba, int index, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be,
+ UNSAFE.getAndAdd$RawType$(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static $type$ addAndGet(ArrayHandle handle, Object oba, int index, $type$ value) {
+ byte[] ba = (byte[]) oba;
+ return convEndian(handle.be, UNSAFE.getAndAdd$RawType$(
+ ba,
+ address(ba, index(ba, index)),
+ convEndian(handle.be, value))) + value;
+ }
+#end[AtomicAdd]
+ }
+
+
+ static final class ByteBufferHandle extends ByteArrayViewVarHandle {
+
+ ByteBufferHandle(boolean be) {
+ super(ByteBufferHandle.class, ByteBuffer.class, $type$.class, be);
+ }
+
+ @ForceInline
+ static int index(ByteBuffer bb, int index) {
+ return Objects.checkIndex(index, UNSAFE.getInt(bb, BUFFER_LIMIT) - ALIGN, null);
+ }
+
+ @ForceInline
+ static int indexRO(ByteBuffer bb, int index) {
+ if (UNSAFE.getBoolean(bb, BYTE_BUFFER_IS_READ_ONLY))
+ throw new ReadOnlyBufferException();
+ return Objects.checkIndex(index, UNSAFE.getInt(bb, BUFFER_LIMIT) - ALIGN, null);
+ }
+
+ @ForceInline
+ static long address(ByteBuffer bb, int index) {
+ long address = ((long) index) + UNSAFE.getLong(bb, BUFFER_ADDRESS);
+ if ((address & ALIGN) != 0)
+ throw newIllegalStateExceptionForMisalignedAccess(index);
+ return address;
+ }
+
+ @ForceInline
+ static $type$ get(ByteBufferHandle handle, Object obb, int index) {
+ ByteBuffer bb = (ByteBuffer) obb;
+#if[floatingPoint]
+ $rawType$ rawValue = UNSAFE.get$RawType$Unaligned(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ ((long) index(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
+ handle.be);
+ return $Type$.$rawType$BitsTo$Type$(rawValue);
+#else[floatingPoint]
+ return UNSAFE.get$Type$Unaligned(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ ((long) index(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
+ handle.be);
+#end[floatingPoint]
+ }
+
+ @ForceInline
+ static void set(ByteBufferHandle handle, Object obb, int index, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+#if[floatingPoint]
+ UNSAFE.put$RawType$Unaligned(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ ((long) indexRO(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
+ $Type$.$type$ToRaw$RawType$Bits(value),
+ handle.be);
+#else[floatingPoint]
+ UNSAFE.put$Type$Unaligned(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ ((long) indexRO(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS),
+ value,
+ handle.be);
+#end[floatingPoint]
+ }
+
+ @ForceInline
+ static $type$ getVolatile(ByteBufferHandle handle, Object obb, int index) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.get$RawType$Volatile(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, index(bb, index))));
+ }
+
+ @ForceInline
+ static void setVolatile(ByteBufferHandle handle, Object obb, int index, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ UNSAFE.put$RawType$Volatile(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ getAcquire(ByteBufferHandle handle, Object obb, int index) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.get$RawType$Acquire(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, index(bb, index))));
+ }
+
+ @ForceInline
+ static void setRelease(ByteBufferHandle handle, Object obb, int index, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ UNSAFE.put$RawType$Release(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ getOpaque(ByteBufferHandle handle, Object obb, int index) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.get$RawType$Opaque(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, index(bb, index))));
+ }
+
+ @ForceInline
+ static void setOpaque(ByteBufferHandle handle, Object obb, int index, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ UNSAFE.put$RawType$Opaque(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, value));
+ }
+#if[CAS]
+
+ @ForceInline
+ static boolean compareAndSet(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return UNSAFE.compareAndSwap$RawType$(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ compareAndExchangeVolatile(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.compareAndExchange$RawType$Volatile(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static $type$ compareAndExchangeAcquire(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.compareAndExchange$RawType$Acquire(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static $type$ compareAndExchangeRelease(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.compareAndExchange$RawType$Release(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static boolean weakCompareAndSet(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return UNSAFE.weakCompareAndSwap$RawType$(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static boolean weakCompareAndSetAcquire(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return UNSAFE.weakCompareAndSwap$RawType$Acquire(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static boolean weakCompareAndSetRelease(ByteBufferHandle handle, Object obb, int index, $type$ expected, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return UNSAFE.weakCompareAndSwap$RawType$Release(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, expected), convEndian(handle.be, value));
+ }
+
+ @ForceInline
+ static $type$ getAndSet(ByteBufferHandle handle, Object obb, int index, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.getAndSet$RawType$(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, value)));
+ }
+#end[CAS]
+#if[AtomicAdd]
+
+ @ForceInline
+ static $type$ getAndAdd(ByteBufferHandle handle, Object obb, int index, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.getAndAdd$RawType$(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, value)));
+ }
+
+ @ForceInline
+ static $type$ addAndGet(ByteBufferHandle handle, Object obb, int index, $type$ value) {
+ ByteBuffer bb = (ByteBuffer) obb;
+ return convEndian(handle.be,
+ UNSAFE.getAndAdd$RawType$(
+ UNSAFE.getObject(bb, BYTE_BUFFER_HB),
+ address(bb, indexRO(bb, index)),
+ convEndian(handle.be, value))) + value;
+ }
+#end[AtomicAdd]
+ }
+}