Skip to content
Snippets Groups Projects
Select Git revision
  • f3eb44a94d7aa01de2f2936ce1a31e7e4d340c33
  • master default protected
  • legacy
  • jdk-17.0.13-ga-legacy
  • jdk-17.0.14+4
  • jdk-17.0.14+3
  • jdk-17.0.14+2
  • jdk-17.0.14+1
  • jdk-17.0.13-ga
  • jdk-17.0.13+11
  • jdk-17.0.13+10
  • jdk-17.0.13+9
  • jdk-17.0.13+8
  • jdk-17.0.13+7
  • jdk-17.0.13+6
  • jdk-17.0.14+0
  • jdk-17.0.13+5
  • jdk-17.0.13+4
  • jdk-17.0.13+3
  • jdk-17.0.13+2
  • jdk-17.0.13+1
  • jdk-17.0.13+0
  • jdk-17.0.12-ga
23 results

VarHandles.java

Blame
  • VarHandles.java 44.57 KiB
    /*
     * Copyright (c) 2014, 2018, 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 sun.invoke.util.Wrapper;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.nio.ByteOrder;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.Objects;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    import java.util.stream.Stream;
    
    import static java.lang.invoke.MethodHandleStatics.UNSAFE;
    import static java.lang.invoke.MethodHandleStatics.VAR_HANDLE_IDENTITY_ADAPT;
    import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException;
    
    final class VarHandles {
    
        static ClassValue<ConcurrentMap<Integer, MethodHandle>> ADDRESS_FACTORIES = new ClassValue<>() {
            @Override
            protected ConcurrentMap<Integer, MethodHandle> computeValue(Class<?> type) {
                return new ConcurrentHashMap<>();
            }
        };
    
        static VarHandle makeFieldHandle(MemberName f, Class<?> refc, Class<?> type, boolean isWriteAllowedOnFinalFields) {
            if (!f.isStatic()) {
                long foffset = MethodHandleNatives.objectFieldOffset(f);
                if (!type.isPrimitive()) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleReferences.FieldInstanceReadOnly(refc, foffset, type)
                           : new VarHandleReferences.FieldInstanceReadWrite(refc, foffset, type));
                }
                else if (type == boolean.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleBooleans.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleBooleans.FieldInstanceReadWrite(refc, foffset));
                }
                else if (type == byte.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleBytes.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleBytes.FieldInstanceReadWrite(refc, foffset));
                }
                else if (type == short.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleShorts.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleShorts.FieldInstanceReadWrite(refc, foffset));
                }
                else if (type == char.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleChars.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleChars.FieldInstanceReadWrite(refc, foffset));
                }
                else if (type == int.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleInts.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleInts.FieldInstanceReadWrite(refc, foffset));
                }
                else if (type == long.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleLongs.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleLongs.FieldInstanceReadWrite(refc, foffset));
                }
                else if (type == float.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleFloats.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleFloats.FieldInstanceReadWrite(refc, foffset));
                }
                else if (type == double.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleDoubles.FieldInstanceReadOnly(refc, foffset)
                           : new VarHandleDoubles.FieldInstanceReadWrite(refc, foffset));
                }
                else {
                    throw new UnsupportedOperationException();
                }
            }
            else {
                // TODO This is not lazy on first invocation
                // and might cause some circular initialization issues
    
                // Replace with something similar to direct method handles
                // where a barrier is used then elided after use
    
                if (UNSAFE.shouldBeInitialized(refc))
                    UNSAFE.ensureClassInitialized(refc);
    
                Object base = MethodHandleNatives.staticFieldBase(f);
                long foffset = MethodHandleNatives.staticFieldOffset(f);
                if (!type.isPrimitive()) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleReferences.FieldStaticReadOnly(base, foffset, type)
                           : new VarHandleReferences.FieldStaticReadWrite(base, foffset, type));
                }
                else if (type == boolean.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleBooleans.FieldStaticReadOnly(base, foffset)
                           : new VarHandleBooleans.FieldStaticReadWrite(base, foffset));
                }
                else if (type == byte.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleBytes.FieldStaticReadOnly(base, foffset)
                           : new VarHandleBytes.FieldStaticReadWrite(base, foffset));
                }
                else if (type == short.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleShorts.FieldStaticReadOnly(base, foffset)
                           : new VarHandleShorts.FieldStaticReadWrite(base, foffset));
                }
                else if (type == char.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleChars.FieldStaticReadOnly(base, foffset)
                           : new VarHandleChars.FieldStaticReadWrite(base, foffset));
                }
                else if (type == int.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleInts.FieldStaticReadOnly(base, foffset)
                           : new VarHandleInts.FieldStaticReadWrite(base, foffset));
                }
                else if (type == long.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleLongs.FieldStaticReadOnly(base, foffset)
                           : new VarHandleLongs.FieldStaticReadWrite(base, foffset));
                }
                else if (type == float.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleFloats.FieldStaticReadOnly(base, foffset)
                           : new VarHandleFloats.FieldStaticReadWrite(base, foffset));
                }
                else if (type == double.class) {
                    return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
                           ? new VarHandleDoubles.FieldStaticReadOnly(base, foffset)
                           : new VarHandleDoubles.FieldStaticReadWrite(base, foffset));
                }
                else {
                    throw new UnsupportedOperationException();
                }
            }
        }
    
        // Required by instance field handles
        static Field getFieldFromReceiverAndOffset(Class<?> receiverType,
                                                   long offset,
                                                   Class<?> fieldType) {
            for (Field f : receiverType.getDeclaredFields()) {
                if (Modifier.isStatic(f.getModifiers())) continue;
    
                if (offset == UNSAFE.objectFieldOffset(f)) {
                    assert f.getType() == fieldType;
                    return f;
                }
            }
            throw new InternalError("Field not found at offset");
        }
    
        // Required by instance static field handles
        static Field getStaticFieldFromBaseAndOffset(Object base,
                                                     long offset,
                                                     Class<?> fieldType) {
            // @@@ This is a little fragile assuming the base is the class
            Class<?> receiverType = (Class<?>) base;
            for (Field f : receiverType.getDeclaredFields()) {
                if (!Modifier.isStatic(f.getModifiers())) continue;
    
                if (offset == UNSAFE.staticFieldOffset(f)) {
                    assert f.getType() == fieldType;
                    return f;
                }
            }
            throw new InternalError("Static field not found at offset");
        }
    
        static VarHandle makeArrayElementHandle(Class<?> arrayClass) {
            if (!arrayClass.isArray())
                throw new IllegalArgumentException("not an array: " + arrayClass);
    
            Class<?> componentType = arrayClass.getComponentType();
    
            int aoffset = UNSAFE.arrayBaseOffset(arrayClass);
            int ascale = UNSAFE.arrayIndexScale(arrayClass);
            int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
    
            if (!componentType.isPrimitive()) {
                return maybeAdapt(new VarHandleReferences.Array(aoffset, ashift, arrayClass));
            }
            else if (componentType == boolean.class) {
                return maybeAdapt(new VarHandleBooleans.Array(aoffset, ashift));
            }
            else if (componentType == byte.class) {
                return maybeAdapt(new VarHandleBytes.Array(aoffset, ashift));
            }
            else if (componentType == short.class) {
                return maybeAdapt(new VarHandleShorts.Array(aoffset, ashift));
            }
            else if (componentType == char.class) {
                return maybeAdapt(new VarHandleChars.Array(aoffset, ashift));
            }
            else if (componentType == int.class) {
                return maybeAdapt(new VarHandleInts.Array(aoffset, ashift));
            }
            else if (componentType == long.class) {
                return maybeAdapt(new VarHandleLongs.Array(aoffset, ashift));
            }
            else if (componentType == float.class) {
                return maybeAdapt(new VarHandleFloats.Array(aoffset, ashift));
            }
            else if (componentType == double.class) {
                return maybeAdapt(new VarHandleDoubles.Array(aoffset, ashift));
            }
            else {
                throw new UnsupportedOperationException();
            }
        }
    
        static VarHandle byteArrayViewHandle(Class<?> viewArrayClass,
                                             boolean be) {
            if (!viewArrayClass.isArray())
                throw new IllegalArgumentException("not an array: " + viewArrayClass);
    
            Class<?> viewComponentType = viewArrayClass.getComponentType();
    
            if (viewComponentType == long.class) {
                return maybeAdapt(new VarHandleByteArrayAsLongs.ArrayHandle(be));
            }
            else if (viewComponentType == int.class) {
                return maybeAdapt(new VarHandleByteArrayAsInts.ArrayHandle(be));
            }
            else if (viewComponentType == short.class) {
                return maybeAdapt(new VarHandleByteArrayAsShorts.ArrayHandle(be));
            }
            else if (viewComponentType == char.class) {
                return maybeAdapt(new VarHandleByteArrayAsChars.ArrayHandle(be));
            }
            else if (viewComponentType == double.class) {
                return maybeAdapt(new VarHandleByteArrayAsDoubles.ArrayHandle(be));
            }
            else if (viewComponentType == float.class) {
                return maybeAdapt(new VarHandleByteArrayAsFloats.ArrayHandle(be));
            }
    
            throw new UnsupportedOperationException();
        }
    
        static VarHandle makeByteBufferViewHandle(Class<?> viewArrayClass,
                                                  boolean be) {
            if (!viewArrayClass.isArray())
                throw new IllegalArgumentException("not an array: " + viewArrayClass);
    
            Class<?> viewComponentType = viewArrayClass.getComponentType();
    
            if (viewComponentType == long.class) {
                return maybeAdapt(new VarHandleByteArrayAsLongs.ByteBufferHandle(be));
            }
            else if (viewComponentType == int.class) {
                return maybeAdapt(new VarHandleByteArrayAsInts.ByteBufferHandle(be));
            }
            else if (viewComponentType == short.class) {
                return maybeAdapt(new VarHandleByteArrayAsShorts.ByteBufferHandle(be));
            }
            else if (viewComponentType == char.class) {
                return maybeAdapt(new VarHandleByteArrayAsChars.ByteBufferHandle(be));
            }
            else if (viewComponentType == double.class) {
                return maybeAdapt(new VarHandleByteArrayAsDoubles.ByteBufferHandle(be));
            }
            else if (viewComponentType == float.class) {
                return maybeAdapt(new VarHandleByteArrayAsFloats.ByteBufferHandle(be));
            }
    
            throw new UnsupportedOperationException();
        }
    
        /**
         * Creates a memory access VarHandle.
         *
         * Resulting VarHandle will take a memory address as first argument,
         * and a certain number of coordinate {@code long} parameters, depending on the length
         * of the {@code strides} argument array.
         *
         * Coordinates are multiplied with corresponding scale factors ({@code strides}) and added
         * to a single fixed offset to compute an effective offset from the given MemoryAddress for the access.
         *
         * @param carrier the Java carrier type.
         * @param alignmentMask alignment requirement to be checked upon access. In bytes. Expressed as a mask.
         * @param byteOrder the byte order.
         * @param offset a constant offset for the access.
         * @param strides the scale factors with which to multiply given access coordinates.
         * @return the created VarHandle.
         */
        static VarHandle makeMemoryAddressViewHandle(Class<?> carrier, long alignmentMask,
                                                     ByteOrder byteOrder, long offset, long[] strides) {
            if (!carrier.isPrimitive() || carrier == void.class || carrier == boolean.class) {
                throw new IllegalArgumentException("Invalid carrier: " + carrier.getName());
            }
            long size = Wrapper.forPrimitiveType(carrier).bitWidth() / 8;
            boolean be = byteOrder == ByteOrder.BIG_ENDIAN;
    
            Map<Integer, MethodHandle> carrierFactory = ADDRESS_FACTORIES.get(carrier);
            MethodHandle fac = carrierFactory.computeIfAbsent(strides.length,
                    dims -> new MemoryAccessVarHandleGenerator(carrier, dims)
                                .generateHandleFactory());
    
            try {
                return maybeAdapt((VarHandle)fac.invoke(be, size, offset, alignmentMask, strides));
            } catch (Throwable ex) {
                throw new IllegalStateException(ex);
            }
        }
    
        private static VarHandle maybeAdapt(VarHandle target) {
            if (!VAR_HANDLE_IDENTITY_ADAPT) return target;
            target = filterValue(target,
                            MethodHandles.identity(target.varType()), MethodHandles.identity(target.varType()));
            MethodType mtype = target.accessModeType(VarHandle.AccessMode.GET).dropParameterTypes(0, 1);
            for (int i = 0 ; i < mtype.parameterCount() ; i++) {
                target = filterCoordinates(target, i, MethodHandles.identity(mtype.parameterType(i)));
            }
            return target;
        }
    
        public static VarHandle filterValue(VarHandle target, MethodHandle filterToTarget, MethodHandle filterFromTarget) {
            Objects.nonNull(target);
            Objects.nonNull(filterToTarget);
            Objects.nonNull(filterFromTarget);
            //check that from/to filters do not throw checked exceptions
            noCheckedExceptions(filterToTarget);
            noCheckedExceptions(filterFromTarget);
    
            List<Class<?>> newCoordinates = new ArrayList<>();
            List<Class<?>> additionalCoordinates = new ArrayList<>();
            newCoordinates.addAll(target.coordinateTypes());
    
            //check that from/to filters have right signatures
            if (filterFromTarget.type().parameterCount() != filterToTarget.type().parameterCount()) {
                throw newIllegalArgumentException("filterFromTarget and filterToTarget have different arity", filterFromTarget.type(), filterToTarget.type());
            } else if (filterFromTarget.type().parameterCount() < 1) {
                throw newIllegalArgumentException("filterFromTarget filter type has wrong arity", filterFromTarget.type());
            } else if (filterToTarget.type().parameterCount() < 1) {
                throw newIllegalArgumentException("filterToTarget filter type has wrong arity", filterFromTarget.type());
            } else if (filterFromTarget.type().lastParameterType() != filterToTarget.type().returnType() ||
                    filterToTarget.type().lastParameterType() != filterFromTarget.type().returnType()) {
                throw newIllegalArgumentException("filterFromTarget and filterToTarget filter types do not match", filterFromTarget.type(), filterToTarget.type());
            } else if (target.varType() != filterFromTarget.type().lastParameterType()) {
                throw newIllegalArgumentException("filterFromTarget filter type does not match target var handle type", filterFromTarget.type(), target.varType());
            } else if (target.varType() != filterToTarget.type().returnType()) {
                throw newIllegalArgumentException("filterFromTarget filter type does not match target var handle type", filterToTarget.type(), target.varType());
            } else if (filterFromTarget.type().parameterCount() > 1) {
                for (int i = 0 ; i < filterFromTarget.type().parameterCount() - 1 ; i++) {
                    if (filterFromTarget.type().parameterType(i) != filterToTarget.type().parameterType(i)) {
                        throw newIllegalArgumentException("filterFromTarget and filterToTarget filter types do not match", filterFromTarget.type(), filterToTarget.type());
                    } else {
                        newCoordinates.add(filterFromTarget.type().parameterType(i));
                        additionalCoordinates.add((filterFromTarget.type().parameterType(i)));
                    }
                }
            }
    
            return new IndirectVarHandle(target, filterFromTarget.type().returnType(), newCoordinates.toArray(new Class<?>[0]),
                    (mode, modeHandle) -> {
                        int lastParameterPos = modeHandle.type().parameterCount() - 1;
                        return switch (mode.at) {
                            case GET -> MethodHandles.collectReturnValue(modeHandle, filterFromTarget);
                            case SET -> MethodHandles.collectArguments(modeHandle, lastParameterPos, filterToTarget);
                            case GET_AND_UPDATE -> {
                                MethodHandle adapter = MethodHandles.collectReturnValue(modeHandle, filterFromTarget);
                                MethodHandle res = MethodHandles.collectArguments(adapter, lastParameterPos, filterToTarget);
                                if (additionalCoordinates.size() > 0) {
                                    res = joinDuplicateArgs(res, lastParameterPos,
                                            lastParameterPos + additionalCoordinates.size() + 1,
                                            additionalCoordinates.size());
                                }
                                yield res;
                            }
                            case COMPARE_AND_EXCHANGE -> {
                                MethodHandle adapter = MethodHandles.collectReturnValue(modeHandle, filterFromTarget);
                                adapter = MethodHandles.collectArguments(adapter, lastParameterPos, filterToTarget);
                                if (additionalCoordinates.size() > 0) {
                                    adapter = joinDuplicateArgs(adapter, lastParameterPos,
                                            lastParameterPos + additionalCoordinates.size() + 1,
                                            additionalCoordinates.size());
                                }
                                MethodHandle res = MethodHandles.collectArguments(adapter, lastParameterPos - 1, filterToTarget);
                                if (additionalCoordinates.size() > 0) {
                                    res = joinDuplicateArgs(res, lastParameterPos - 1,
                                            lastParameterPos + additionalCoordinates.size(),
                                            additionalCoordinates.size());
                                }
                                yield res;
                            }
                            case COMPARE_AND_SET -> {
                                MethodHandle adapter = MethodHandles.collectArguments(modeHandle, lastParameterPos, filterToTarget);
                                MethodHandle res = MethodHandles.collectArguments(adapter, lastParameterPos - 1, filterToTarget);
                                if (additionalCoordinates.size() > 0) {
                                    res = joinDuplicateArgs(res, lastParameterPos - 1,
                                            lastParameterPos + additionalCoordinates.size(),
                                            additionalCoordinates.size());
                                }
                                yield res;
                            }
                        };
                    });
        }
    
        private static MethodHandle joinDuplicateArgs(MethodHandle handle, int originalStart, int dropStart, int length) {
            int[] perms = new int[handle.type().parameterCount()];
            for (int i = 0 ; i < dropStart; i++) {
                perms[i] = i;
            }
            for (int i = 0 ; i < length ; i++) {
                perms[dropStart + i] = originalStart + i;
            }
            for (int i = dropStart + length ; i < perms.length ; i++) {
                perms[i] = i - length;
            }
            return MethodHandles.permuteArguments(handle,
                    handle.type().dropParameterTypes(dropStart, dropStart + length),
                    perms);
        }
    
        public static VarHandle filterCoordinates(VarHandle target, int pos, MethodHandle... filters) {
            Objects.nonNull(target);
            Objects.nonNull(filters);
    
            List<Class<?>> targetCoordinates = target.coordinateTypes();
            if (pos < 0 || pos >= targetCoordinates.size()) {
                throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
            } else if (pos + filters.length > targetCoordinates.size()) {
                throw new IllegalArgumentException("Too many filters");
            }
    
            if (filters.length == 0) return target;
    
            List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
            for (int i = 0 ; i < filters.length ; i++) {
                noCheckedExceptions(filters[i]);
                MethodType filterType = filters[i].type();
                if (filterType.parameterCount() != 1) {
                    throw newIllegalArgumentException("Invalid filter type " + filterType);
                } else if (newCoordinates.get(pos + i) != filterType.returnType()) {
                    throw newIllegalArgumentException("Invalid filter type " + filterType + " for coordinate type " + newCoordinates.get(i));
                }
                newCoordinates.set(pos + i, filters[i].type().parameterType(0));
            }
    
            return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
                    (mode, modeHandle) -> MethodHandles.filterArguments(modeHandle, 1 + pos, filters));
        }
    
        public static VarHandle insertCoordinates(VarHandle target, int pos, Object... values) {
            Objects.nonNull(target);
            Objects.nonNull(values);
    
            List<Class<?>> targetCoordinates = target.coordinateTypes();
            if (pos < 0 || pos >= targetCoordinates.size()) {
                throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
            } else if (pos + values.length > targetCoordinates.size()) {
                throw new IllegalArgumentException("Too many values");
            }
    
            if (values.length == 0) return target;
    
            List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
            for (int i = 0 ; i < values.length ; i++) {
                Class<?> pt = newCoordinates.get(pos);
                if (pt.isPrimitive()) {
                    Wrapper w = Wrapper.forPrimitiveType(pt);
                    w.convert(values[i], pt);
                } else {
                    pt.cast(values[i]);
                }
                newCoordinates.remove(pos);
            }
    
            return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
                    (mode, modeHandle) -> MethodHandles.insertArguments(modeHandle, 1 + pos, values));
        }
    
        public static VarHandle permuteCoordinates(VarHandle target, List<Class<?>> newCoordinates, int... reorder) {
            Objects.nonNull(target);
            Objects.nonNull(newCoordinates);
            Objects.nonNull(reorder);
    
            List<Class<?>> targetCoordinates = target.coordinateTypes();
            MethodHandles.permuteArgumentChecks(reorder,
                    MethodType.methodType(void.class, newCoordinates),
                    MethodType.methodType(void.class, targetCoordinates));
    
            return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
                    (mode, modeHandle) ->
                            MethodHandles.permuteArguments(modeHandle,
                                    methodTypeFor(mode.at, modeHandle.type(), targetCoordinates, newCoordinates),
                                    reorderArrayFor(mode.at, newCoordinates, reorder)));
        }
    
        private static int numTrailingArgs(VarHandle.AccessType at) {
            return switch (at) {
                case GET -> 0;
                case GET_AND_UPDATE, SET -> 1;
                case COMPARE_AND_SET, COMPARE_AND_EXCHANGE -> 2;
            };
        }
    
        private static int[] reorderArrayFor(VarHandle.AccessType at, List<Class<?>> newCoordinates, int[] reorder) {
            int numTrailingArgs = numTrailingArgs(at);
            int[] adjustedReorder = new int[reorder.length + 1 + numTrailingArgs];
            adjustedReorder[0] = 0;
            for (int i = 0 ; i < reorder.length ; i++) {
                adjustedReorder[i + 1] = reorder[i] + 1;
            }
            for (int i = 0 ; i < numTrailingArgs ; i++) {
                adjustedReorder[i + reorder.length + 1] = i + newCoordinates.size() + 1;
            }
            return adjustedReorder;
        }
    
        private static MethodType methodTypeFor(VarHandle.AccessType at, MethodType oldType, List<Class<?>> oldCoordinates, List<Class<?>> newCoordinates) {
            int numTrailingArgs = numTrailingArgs(at);
            MethodType adjustedType = MethodType.methodType(oldType.returnType(), oldType.parameterType(0));
            adjustedType = adjustedType.appendParameterTypes(newCoordinates);
            for (int i = 0 ; i < numTrailingArgs ; i++) {
                adjustedType = adjustedType.appendParameterTypes(oldType.parameterType(1 + oldCoordinates.size() + i));
            }
            return adjustedType;
        }
    
        public static VarHandle collectCoordinates(VarHandle target, int pos, MethodHandle filter) {
            Objects.nonNull(target);
            Objects.nonNull(filter);
            noCheckedExceptions(filter);
    
            List<Class<?>> targetCoordinates = target.coordinateTypes();
            if (pos < 0 || pos >= targetCoordinates.size()) {
                throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
            } else if (filter.type().returnType() == void.class) {
                throw newIllegalArgumentException("Invalid filter type " + filter.type() + " ; filter cannot be void");
            } else if (filter.type().returnType() != targetCoordinates.get(pos)) {
                throw newIllegalArgumentException("Invalid filter type " + filter.type() + " for coordinate type " + targetCoordinates.get(pos));
            }
    
            List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
            newCoordinates.remove(pos);
            newCoordinates.addAll(pos, filter.type().parameterList());
    
            return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
                    (mode, modeHandle) -> MethodHandles.collectArguments(modeHandle, 1 + pos, filter));
        }
    
        public static VarHandle dropCoordinates(VarHandle target, int pos, Class<?>... valueTypes) {
            Objects.nonNull(target);
            Objects.nonNull(valueTypes);
    
            List<Class<?>> targetCoordinates = target.coordinateTypes();
            if (pos < 0 || pos > targetCoordinates.size()) {
                throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
            }
    
            if (valueTypes.length == 0) return target;
    
            List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
            newCoordinates.addAll(pos, List.of(valueTypes));
    
            return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
                    (mode, modeHandle) -> MethodHandles.dropArguments(modeHandle, 1 + pos, valueTypes));
        }
    
        private static void noCheckedExceptions(MethodHandle handle) {
            if (handle instanceof DirectMethodHandle) {
                DirectMethodHandle directHandle = (DirectMethodHandle)handle;
                byte refKind = directHandle.member.getReferenceKind();
                MethodHandleInfo info = new InfoFromMemberName(
                        MethodHandles.Lookup.IMPL_LOOKUP,
                        directHandle.member,
                        refKind);
                final Class<?>[] exceptionTypes;
                if (MethodHandleNatives.refKindIsMethod(refKind)) {
                    exceptionTypes = info.reflectAs(Method.class, MethodHandles.Lookup.IMPL_LOOKUP)
                            .getExceptionTypes();
                } else if (MethodHandleNatives.refKindIsField(refKind)) {
                    exceptionTypes = null;
                } else if (MethodHandleNatives.refKindIsConstructor(refKind)) {
                    exceptionTypes = info.reflectAs(Constructor.class, MethodHandles.Lookup.IMPL_LOOKUP)
                            .getExceptionTypes();
                } else {
                    throw new AssertionError("Cannot get here");
                }
                if (exceptionTypes != null) {
                    if (Stream.of(exceptionTypes).anyMatch(VarHandles::isCheckedException)) {
                        throw newIllegalArgumentException("Cannot adapt a var handle with a method handle which throws checked exceptions");
                    }
                }
            } else if (handle instanceof DelegatingMethodHandle) {
                noCheckedExceptions(((DelegatingMethodHandle)handle).getTarget());
            } else {
                //bound
                BoundMethodHandle boundHandle = (BoundMethodHandle)handle;
                for (int i = 0 ; i < boundHandle.fieldCount() ; i++) {
                    Object arg = boundHandle.arg(i);
                    if (arg instanceof MethodHandle){
                        noCheckedExceptions((MethodHandle) arg);
                    }
                }
            }
        }
    
        private static boolean isCheckedException(Class<?> clazz) {
            return Throwable.class.isAssignableFrom(clazz) &&
                    !RuntimeException.class.isAssignableFrom(clazz) &&
                    !Error.class.isAssignableFrom(clazz);
        }
    
    //    /**
    //     * A helper program to generate the VarHandleGuards class with a set of
    //     * static guard methods each of which corresponds to a particular shape and
    //     * performs a type check of the symbolic type descriptor with the VarHandle
    //     * type descriptor before linking/invoking to the underlying operation as
    //     * characterized by the operation member name on the VarForm of the
    //     * VarHandle.
    //     * <p>
    //     * The generated class essentially encapsulates pre-compiled LambdaForms,
    //     * one for each method, for the most set of common method signatures.
    //     * This reduces static initialization costs, footprint costs, and circular
    //     * dependencies that may arise if a class is generated per LambdaForm.
    //     * <p>
    //     * A maximum of L*T*S methods will be generated where L is the number of
    //     * access modes kinds (or unique operation signatures) and T is the number
    //     * of variable types and S is the number of shapes (such as instance field,
    //     * static field, or array access).
    //     * If there are 4 unique operation signatures, 5 basic types (Object, int,
    //     * long, float, double), and 3 shapes then a maximum of 60 methods will be
    //     * generated.  However, the number is likely to be less since there
    //     * be duplicate signatures.
    //     * <p>
    //     * Each method is annotated with @LambdaForm.Compiled to inform the runtime
    //     * that such methods should be treated as if a method of a class that is the
    //     * result of compiling a LambdaForm.  Annotation of such methods is
    //     * important for correct evaluation of certain assertions and method return
    //     * type profiling in HotSpot.
    //     */
    //    public static class GuardMethodGenerator {
    //
    //        static final String GUARD_METHOD_SIG_TEMPLATE = "<RETURN> <NAME>_<SIGNATURE>(<PARAMS>)";
    //
    //        static final String GUARD_METHOD_TEMPLATE =
    //                "@ForceInline\n" +
    //                "@LambdaForm.Compiled\n" +
    //                "final static <METHOD> throws Throwable {\n" +
    //                "    if (handle.isDirect() && handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
    //                "        <RESULT_ERASED>MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);<RETURN_ERASED>\n" +
    //                "    }\n" +
    //                "    else {\n" +
    //                "        MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
    //                "        <RETURN>mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
    //                "    }\n" +
    //                "}";
    //
    //        static final String GUARD_METHOD_TEMPLATE_V =
    //                "@ForceInline\n" +
    //                "@LambdaForm.Compiled\n" +
    //                "final static <METHOD> throws Throwable {\n" +
    //                "    if (handle.isDirect() && handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
    //                "        MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
    //                "    }\n" +
    //                "    else if (handle.isDirect() && handle.vform.getMethodType_V(ad.type) == ad.symbolicMethodType) {\n" +
    //                "        MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
    //                "    }\n" +
    //                "    else {\n" +
    //                "        MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
    //                "        mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
    //                "    }\n" +
    //                "}";
    //
    //        // A template for deriving the operations
    //        // could be supported by annotating VarHandle directly with the
    //        // operation kind and shape
    //        interface VarHandleTemplate {
    //            Object get();
    //
    //            void set(Object value);
    //
    //            boolean compareAndSet(Object actualValue, Object expectedValue);
    //
    //            Object compareAndExchange(Object actualValue, Object expectedValue);
    //
    //            Object getAndUpdate(Object value);
    //        }
    //
    //        static class HandleType {
    //            final Class<?> receiver;
    //            final Class<?>[] intermediates;
    //            final Class<?> value;
    //
    //            HandleType(Class<?> receiver, Class<?> value, Class<?>... intermediates) {
    //                this.receiver = receiver;
    //                this.intermediates = intermediates;
    //                this.value = value;
    //            }
    //        }
    //
    //        /**
    //         * @param args parameters
    //         */
    //        public static void main(String[] args) {
    //            System.out.println("package java.lang.invoke;");
    //            System.out.println();
    //            System.out.println("import jdk.internal.vm.annotation.ForceInline;");
    //            System.out.println();
    //            System.out.println("// This class is auto-generated by " +
    //                               GuardMethodGenerator.class.getName() +
    //                               ". Do not edit.");
    //            System.out.println("final class VarHandleGuards {");
    //
    //            System.out.println();
    //
    //            // Declare the stream of shapes
    //            Stream<HandleType> hts = Stream.of(
    //                    // Object->Object
    //                    new HandleType(Object.class, Object.class),
    //                    // Object->int
    //                    new HandleType(Object.class, int.class),
    //                    // Object->long
    //                    new HandleType(Object.class, long.class),
    //                    // Object->float
    //                    new HandleType(Object.class, float.class),
    //                    // Object->double
    //                    new HandleType(Object.class, double.class),
    //
    //                    // <static>->Object
    //                    new HandleType(null, Object.class),
    //                    // <static>->int
    //                    new HandleType(null, int.class),
    //                    // <static>->long
    //                    new HandleType(null, long.class),
    //                    // <static>->float
    //                    new HandleType(null, float.class),
    //                    // <static>->double
    //                    new HandleType(null, double.class),
    //
    //                    // Array[int]->Object
    //                    new HandleType(Object.class, Object.class, int.class),
    //                    // Array[int]->int
    //                    new HandleType(Object.class, int.class, int.class),
    //                    // Array[int]->long
    //                    new HandleType(Object.class, long.class, int.class),
    //                    // Array[int]->float
    //                    new HandleType(Object.class, float.class, int.class),
    //                    // Array[int]->double
    //                    new HandleType(Object.class, double.class, int.class),
    //
    //                    // Array[long]->int
    //                    new HandleType(Object.class, int.class, long.class),
    //                    // Array[long]->long
    //                    new HandleType(Object.class, long.class, long.class)
    //            );
    //
    //            hts.flatMap(ht -> Stream.of(VarHandleTemplate.class.getMethods()).
    //                    map(m -> generateMethodType(m, ht.receiver, ht.value, ht.intermediates))).
    //                    distinct().
    //                    map(mt -> generateMethod(mt)).
    //                    forEach(s -> {
    //                        System.out.println(s);
    //                        System.out.println();
    //                    });
    //
    //            System.out.println("}");
    //        }
    //
    //        static MethodType generateMethodType(Method m, Class<?> receiver, Class<?> value, Class<?>... intermediates) {
    //            Class<?> returnType = m.getReturnType() == Object.class
    //                                  ? value : m.getReturnType();
    //
    //            List<Class<?>> params = new ArrayList<>();
    //            if (receiver != null)
    //                params.add(receiver);
    //            for (int i = 0; i < intermediates.length; i++) {
    //                params.add(intermediates[i]);
    //            }
    //            for (Parameter p : m.getParameters()) {
    //                params.add(value);
    //            }
    //            return MethodType.methodType(returnType, params);
    //        }
    //
    //        static String generateMethod(MethodType mt) {
    //            Class<?> returnType = mt.returnType();
    //
    //            LinkedHashMap<String, Class<?>> params = new LinkedHashMap<>();
    //            params.put("handle", VarHandle.class);
    //            for (int i = 0; i < mt.parameterCount(); i++) {
    //                params.put("arg" + i, mt.parameterType(i));
    //            }
    //            params.put("ad", VarHandle.AccessDescriptor.class);
    //
    //            // Generate method signature line
    //            String RETURN = className(returnType);
    //            String NAME = "guard";
    //            String SIGNATURE = getSignature(mt);
    //            String PARAMS = params.entrySet().stream().
    //                    map(e -> className(e.getValue()) + " " + e.getKey()).
    //                    collect(joining(", "));
    //            String METHOD = GUARD_METHOD_SIG_TEMPLATE.
    //                    replace("<RETURN>", RETURN).
    //                    replace("<NAME>", NAME).
    //                    replace("<SIGNATURE>", SIGNATURE).
    //                    replace("<PARAMS>", PARAMS);
    //
    //            // Generate method
    //            params.remove("ad");
    //
    //            List<String> LINK_TO_STATIC_ARGS = params.keySet().stream().
    //                    collect(toList());
    //            LINK_TO_STATIC_ARGS.add("handle.vform.getMemberName(ad.mode)");
    //            List<String> LINK_TO_STATIC_ARGS_V = params.keySet().stream().
    //                    collect(toList());
    //            LINK_TO_STATIC_ARGS_V.add("handle.vform.getMemberName_V(ad.mode)");
    //
    //            List<String> LINK_TO_INVOKER_ARGS = params.keySet().stream().
    //                    collect(toList());
    //
    //            RETURN = returnType == void.class
    //                     ? ""
    //                     : returnType == Object.class
    //                       ? "return "
    //                       : "return (" + returnType.getName() + ") ";
    //
    //            String RESULT_ERASED = returnType == void.class
    //                                   ? ""
    //                                   : returnType != Object.class
    //                                     ? "return (" + returnType.getName() + ") "
    //                                     : "Object r = ";
    //
    //            String RETURN_ERASED = returnType != Object.class
    //                                   ? ""
    //                                   : " return ad.returnType.cast(r);";
    //
    //            String template = returnType == void.class
    //                              ? GUARD_METHOD_TEMPLATE_V
    //                              : GUARD_METHOD_TEMPLATE;
    //            return template.
    //                    replace("<METHOD>", METHOD).
    //                    replace("<NAME>", NAME).
    //                    replaceAll("<RETURN>", RETURN).
    //                    replace("<RESULT_ERASED>", RESULT_ERASED).
    //                    replace("<RETURN_ERASED>", RETURN_ERASED).
    //                    replaceAll("<LINK_TO_STATIC_ARGS>", LINK_TO_STATIC_ARGS.stream().
    //                            collect(joining(", "))).
    //                    replaceAll("<LINK_TO_STATIC_ARGS_V>", LINK_TO_STATIC_ARGS_V.stream().
    //                            collect(joining(", "))).
    //                    replace("<LINK_TO_INVOKER_ARGS>", LINK_TO_INVOKER_ARGS.stream().
    //                            collect(joining(", ")))
    //                    ;
    //        }
    //
    //        static String className(Class<?> c) {
    //            String n = c.getName();
    //            if (n.startsWith("java.lang.")) {
    //                n = n.replace("java.lang.", "");
    //                if (n.startsWith("invoke.")) {
    //                    n = n.replace("invoke.", "");
    //                }
    //            }
    //            return n.replace('$', '.');
    //        }
    //
    //        static String getSignature(MethodType m) {
    //            StringBuilder sb = new StringBuilder(m.parameterCount() + 1);
    //
    //            for (int i = 0; i < m.parameterCount(); i++) {
    //                Class<?> pt = m.parameterType(i);
    //                sb.append(getCharType(pt));
    //            }
    //
    //            sb.append('_').append(getCharType(m.returnType()));
    //
    //            return sb.toString();
    //        }
    //
    //        static char getCharType(Class<?> pt) {
    //            if (pt == void.class) {
    //                return 'V';
    //            }
    //            else if (!pt.isPrimitive()) {
    //                return 'L';
    //            }
    //            else if (pt == boolean.class) {
    //                return 'Z';
    //            }
    //            else if (pt == int.class) {
    //                return 'I';
    //            }
    //            else if (pt == long.class) {
    //                return 'J';
    //            }
    //            else if (pt == float.class) {
    //                return 'F';
    //            }
    //            else if (pt == double.class) {
    //                return 'D';
    //            }
    //            else {
    //                throw new IllegalStateException(pt.getName());
    //            }
    //        }
    //    }
    }