1 /*
  2  * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.  Oracle designates this
  8  * particular file as subject to the "Classpath" exception as provided
  9  * by Oracle in the LICENSE file that accompanied this code.
 10  *
 11  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  * version 2 for more details (a copy is included in the LICENSE file that
 15  * accompanied this code).
 16  *
 17  * You should have received a copy of the GNU General Public License version
 18  * 2 along with this work; if not, write to the Free Software Foundation,
 19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  *
 21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  */
 25 
 26 package java.lang.invoke;
 27 
 28 import sun.invoke.util.Wrapper;
 29 
 30 import java.lang.reflect.Constructor;
 31 import java.lang.reflect.Field;
 32 import java.lang.reflect.Method;
 33 import java.lang.reflect.Modifier;
 34 import java.nio.ByteOrder;
 35 import java.util.ArrayList;
 36 import java.util.List;
 37 import java.util.Objects;
 38 import java.util.concurrent.ConcurrentHashMap;
 39 import java.util.concurrent.ConcurrentMap;
 40 import java.util.stream.Stream;
 41 
 42 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
 43 import static java.lang.invoke.MethodHandleStatics.VAR_HANDLE_IDENTITY_ADAPT;
 44 import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException;
 45 
 46 final class VarHandles {
 47 
 48     static ClassValue<ConcurrentMap<Integer, MethodHandle>> ADDRESS_FACTORIES = new ClassValue<>() {
 49         @Override
 50         protected ConcurrentMap<Integer, MethodHandle> computeValue(Class<?> type) {
 51             return new ConcurrentHashMap<>();
 52         }
 53     };
 54 
 55     static VarHandle makeFieldHandle(MemberName f, Class<?> refc, Class<?> type, boolean isWriteAllowedOnFinalFields) {
 56         if (!f.isStatic()) {
 57             long foffset = MethodHandleNatives.objectFieldOffset(f);
 58             if (!type.isPrimitive()) {
 59                 if (f.isFlattened()) {
 60                     return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 61                         ? new VarHandleValues.FieldInstanceReadOnly(refc, foffset, type)
 62                         : new VarHandleValues.FieldInstanceReadWrite(refc, foffset, type));
 63                 } else {
 64                     return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 65                        ? new VarHandleReferences.FieldInstanceReadOnly(refc, foffset, type)
 66                        : new VarHandleReferences.FieldInstanceReadWrite(refc, foffset, type));
 67                 }
 68             }
 69             else if (type == boolean.class) {
 70                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 71                        ? new VarHandleBooleans.FieldInstanceReadOnly(refc, foffset)
 72                        : new VarHandleBooleans.FieldInstanceReadWrite(refc, foffset));
 73             }
 74             else if (type == byte.class) {
 75                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 76                        ? new VarHandleBytes.FieldInstanceReadOnly(refc, foffset)
 77                        : new VarHandleBytes.FieldInstanceReadWrite(refc, foffset));
 78             }
 79             else if (type == short.class) {
 80                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 81                        ? new VarHandleShorts.FieldInstanceReadOnly(refc, foffset)
 82                        : new VarHandleShorts.FieldInstanceReadWrite(refc, foffset));
 83             }
 84             else if (type == char.class) {
 85                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 86                        ? new VarHandleChars.FieldInstanceReadOnly(refc, foffset)
 87                        : new VarHandleChars.FieldInstanceReadWrite(refc, foffset));
 88             }
 89             else if (type == int.class) {
 90                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 91                        ? new VarHandleInts.FieldInstanceReadOnly(refc, foffset)
 92                        : new VarHandleInts.FieldInstanceReadWrite(refc, foffset));
 93             }
 94             else if (type == long.class) {
 95                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
 96                        ? new VarHandleLongs.FieldInstanceReadOnly(refc, foffset)
 97                        : new VarHandleLongs.FieldInstanceReadWrite(refc, foffset));
 98             }
 99             else if (type == float.class) {
100                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
101                        ? new VarHandleFloats.FieldInstanceReadOnly(refc, foffset)
102                        : new VarHandleFloats.FieldInstanceReadWrite(refc, foffset));
103             }
104             else if (type == double.class) {
105                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
106                        ? new VarHandleDoubles.FieldInstanceReadOnly(refc, foffset)
107                        : new VarHandleDoubles.FieldInstanceReadWrite(refc, foffset));
108             }
109             else {
110                 throw new UnsupportedOperationException();
111             }
112         }
113         else {
114             // TODO This is not lazy on first invocation
115             // and might cause some circular initialization issues
116 
117             // Replace with something similar to direct method handles
118             // where a barrier is used then elided after use
119 
120             if (UNSAFE.shouldBeInitialized(refc))
121                 UNSAFE.ensureClassInitialized(refc);
122 
123             Object base = MethodHandleNatives.staticFieldBase(f);
124             long foffset = MethodHandleNatives.staticFieldOffset(f);
125             if (!type.isPrimitive()) {
126                 if (f.isFlattened()) {
127                     return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
128                             ? new VarHandleValues.FieldStaticReadOnly(refc, foffset, type)
129                             : new VarHandleValues.FieldStaticReadWrite(refc, foffset, type));
130                 } else {
131                     return f.isFinal() && !isWriteAllowedOnFinalFields
132                             ? new VarHandleReferences.FieldStaticReadOnly(base, foffset, type)
133                             : new VarHandleReferences.FieldStaticReadWrite(base, foffset, type);
134                 }
135             }
136             else if (type == boolean.class) {
137                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
138                        ? new VarHandleBooleans.FieldStaticReadOnly(base, foffset)
139                        : new VarHandleBooleans.FieldStaticReadWrite(base, foffset));
140             }
141             else if (type == byte.class) {
142                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
143                        ? new VarHandleBytes.FieldStaticReadOnly(base, foffset)
144                        : new VarHandleBytes.FieldStaticReadWrite(base, foffset));
145             }
146             else if (type == short.class) {
147                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
148                        ? new VarHandleShorts.FieldStaticReadOnly(base, foffset)
149                        : new VarHandleShorts.FieldStaticReadWrite(base, foffset));
150             }
151             else if (type == char.class) {
152                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
153                        ? new VarHandleChars.FieldStaticReadOnly(base, foffset)
154                        : new VarHandleChars.FieldStaticReadWrite(base, foffset));
155             }
156             else if (type == int.class) {
157                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
158                        ? new VarHandleInts.FieldStaticReadOnly(base, foffset)
159                        : new VarHandleInts.FieldStaticReadWrite(base, foffset));
160             }
161             else if (type == long.class) {
162                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
163                        ? new VarHandleLongs.FieldStaticReadOnly(base, foffset)
164                        : new VarHandleLongs.FieldStaticReadWrite(base, foffset));
165             }
166             else if (type == float.class) {
167                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
168                        ? new VarHandleFloats.FieldStaticReadOnly(base, foffset)
169                        : new VarHandleFloats.FieldStaticReadWrite(base, foffset));
170             }
171             else if (type == double.class) {
172                 return maybeAdapt(f.isFinal() && !isWriteAllowedOnFinalFields
173                        ? new VarHandleDoubles.FieldStaticReadOnly(base, foffset)
174                        : new VarHandleDoubles.FieldStaticReadWrite(base, foffset));
175             }
176             else {
177                 throw new UnsupportedOperationException();
178             }
179         }
180     }
181 
182     // Required by instance field handles
183     static Field getFieldFromReceiverAndOffset(Class<?> receiverType,
184                                                long offset,
185                                                Class<?> fieldType) {
186         for (Field f : receiverType.getDeclaredFields()) {
187             if (Modifier.isStatic(f.getModifiers())) continue;
188 
189             if (offset == UNSAFE.objectFieldOffset(f)) {
190                 assert f.getType() == fieldType;
191                 return f;
192             }
193         }
194         throw new InternalError("Field not found at offset");
195     }
196 
197     // Required by instance static field handles
198     static Field getStaticFieldFromBaseAndOffset(Object base,
199                                                  long offset,
200                                                  Class<?> fieldType) {
201         // @@@ This is a little fragile assuming the base is the class
202         Class<?> receiverType = (Class<?>) base;
203         for (Field f : receiverType.getDeclaredFields()) {
204             if (!Modifier.isStatic(f.getModifiers())) continue;
205 
206             if (offset == UNSAFE.staticFieldOffset(f)) {
207                 assert f.getType() == fieldType;
208                 return f;
209             }
210         }
211         throw new InternalError("Static field not found at offset");
212     }
213 
214     static VarHandle makeArrayElementHandle(Class<?> arrayClass) {
215         if (!arrayClass.isArray())
216             throw new IllegalArgumentException("not an array: " + arrayClass);
217 
218         Class<?> componentType = arrayClass.getComponentType();
219 
220         int aoffset = UNSAFE.arrayBaseOffset(arrayClass);
221         int ascale = UNSAFE.arrayIndexScale(arrayClass);
222         int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
223 
224         if (!componentType.isPrimitive()) {
225             // the redundant componentType.isPrimitiveValueType() check is
226             // there to minimize the performance impact to non-value array.
227             // It should be removed when Unsafe::isFlattenedArray is intrinsified.
228             return maybeAdapt(componentType.isPrimitiveValueType() && UNSAFE.isFlattenedArray(arrayClass)
229                 ? new VarHandleValues.Array(aoffset, ashift, arrayClass)
230                 : new VarHandleReferences.Array(aoffset, ashift, arrayClass));
231         }
232         else if (componentType == boolean.class) {
233             return maybeAdapt(new VarHandleBooleans.Array(aoffset, ashift));
234         }
235         else if (componentType == byte.class) {
236             return maybeAdapt(new VarHandleBytes.Array(aoffset, ashift));
237         }
238         else if (componentType == short.class) {
239             return maybeAdapt(new VarHandleShorts.Array(aoffset, ashift));
240         }
241         else if (componentType == char.class) {
242             return maybeAdapt(new VarHandleChars.Array(aoffset, ashift));
243         }
244         else if (componentType == int.class) {
245             return maybeAdapt(new VarHandleInts.Array(aoffset, ashift));
246         }
247         else if (componentType == long.class) {
248             return maybeAdapt(new VarHandleLongs.Array(aoffset, ashift));
249         }
250         else if (componentType == float.class) {
251             return maybeAdapt(new VarHandleFloats.Array(aoffset, ashift));
252         }
253         else if (componentType == double.class) {
254             return maybeAdapt(new VarHandleDoubles.Array(aoffset, ashift));
255         }
256         else {
257             throw new UnsupportedOperationException();
258         }
259     }
260 
261     static VarHandle byteArrayViewHandle(Class<?> viewArrayClass,
262                                          boolean be) {
263         if (!viewArrayClass.isArray())
264             throw new IllegalArgumentException("not an array: " + viewArrayClass);
265 
266         Class<?> viewComponentType = viewArrayClass.getComponentType();
267 
268         if (viewComponentType == long.class) {
269             return maybeAdapt(new VarHandleByteArrayAsLongs.ArrayHandle(be));
270         }
271         else if (viewComponentType == int.class) {
272             return maybeAdapt(new VarHandleByteArrayAsInts.ArrayHandle(be));
273         }
274         else if (viewComponentType == short.class) {
275             return maybeAdapt(new VarHandleByteArrayAsShorts.ArrayHandle(be));
276         }
277         else if (viewComponentType == char.class) {
278             return maybeAdapt(new VarHandleByteArrayAsChars.ArrayHandle(be));
279         }
280         else if (viewComponentType == double.class) {
281             return maybeAdapt(new VarHandleByteArrayAsDoubles.ArrayHandle(be));
282         }
283         else if (viewComponentType == float.class) {
284             return maybeAdapt(new VarHandleByteArrayAsFloats.ArrayHandle(be));
285         }
286 
287         throw new UnsupportedOperationException();
288     }
289 
290     static VarHandle makeByteBufferViewHandle(Class<?> viewArrayClass,
291                                               boolean be) {
292         if (!viewArrayClass.isArray())
293             throw new IllegalArgumentException("not an array: " + viewArrayClass);
294 
295         Class<?> viewComponentType = viewArrayClass.getComponentType();
296 
297         if (viewComponentType == long.class) {
298             return maybeAdapt(new VarHandleByteArrayAsLongs.ByteBufferHandle(be));
299         }
300         else if (viewComponentType == int.class) {
301             return maybeAdapt(new VarHandleByteArrayAsInts.ByteBufferHandle(be));
302         }
303         else if (viewComponentType == short.class) {
304             return maybeAdapt(new VarHandleByteArrayAsShorts.ByteBufferHandle(be));
305         }
306         else if (viewComponentType == char.class) {
307             return maybeAdapt(new VarHandleByteArrayAsChars.ByteBufferHandle(be));
308         }
309         else if (viewComponentType == double.class) {
310             return maybeAdapt(new VarHandleByteArrayAsDoubles.ByteBufferHandle(be));
311         }
312         else if (viewComponentType == float.class) {
313             return maybeAdapt(new VarHandleByteArrayAsFloats.ByteBufferHandle(be));
314         }
315 
316         throw new UnsupportedOperationException();
317     }
318 
319     /**
320      * Creates a memory access VarHandle.
321      *
322      * Resulting VarHandle will take a memory address as first argument,
323      * and a certain number of coordinate {@code long} parameters, depending on the length
324      * of the {@code strides} argument array.
325      *
326      * Coordinates are multiplied with corresponding scale factors ({@code strides}) and added
327      * to a single fixed offset to compute an effective offset from the given MemoryAddress for the access.
328      *
329      * @param carrier the Java carrier type.
330      * @param skipAlignmentMaskCheck if true, only the base part of the address will be checked for alignment.
331      * @param alignmentMask alignment requirement to be checked upon access. In bytes. Expressed as a mask.
332      * @param byteOrder the byte order.
333      * @return the created VarHandle.
334      */
335     static VarHandle makeMemoryAddressViewHandle(Class<?> carrier, boolean skipAlignmentMaskCheck, long alignmentMask,
336                                                  ByteOrder byteOrder) {
337         if (!carrier.isPrimitive() || carrier == void.class || carrier == boolean.class) {
338             throw new IllegalArgumentException("Invalid carrier: " + carrier.getName());
339         }
340         long size = Wrapper.forPrimitiveType(carrier).bitWidth() / 8;
341         boolean be = byteOrder == ByteOrder.BIG_ENDIAN;
342         boolean exact = false;
343 
344         if (carrier == byte.class) {
345             return maybeAdapt(new MemoryAccessVarHandleByteHelper(skipAlignmentMaskCheck, be, size, alignmentMask, exact));
346         } else if (carrier == char.class) {
347             return maybeAdapt(new MemoryAccessVarHandleCharHelper(skipAlignmentMaskCheck, be, size, alignmentMask, exact));
348         } else if (carrier == short.class) {
349             return maybeAdapt(new MemoryAccessVarHandleShortHelper(skipAlignmentMaskCheck, be, size, alignmentMask, exact));
350         } else if (carrier == int.class) {
351             return maybeAdapt(new MemoryAccessVarHandleIntHelper(skipAlignmentMaskCheck, be, size, alignmentMask, exact));
352         } else if (carrier == float.class) {
353             return maybeAdapt(new MemoryAccessVarHandleFloatHelper(skipAlignmentMaskCheck, be, size, alignmentMask, exact));
354         } else if (carrier == long.class) {
355             return maybeAdapt(new MemoryAccessVarHandleLongHelper(skipAlignmentMaskCheck, be, size, alignmentMask, exact));
356         } else if (carrier == double.class) {
357             return maybeAdapt(new MemoryAccessVarHandleDoubleHelper(skipAlignmentMaskCheck, be, size, alignmentMask, exact));
358         } else {
359             throw new IllegalStateException("Cannot get here");
360         }
361     }
362 
363     private static VarHandle maybeAdapt(VarHandle target) {
364         if (!VAR_HANDLE_IDENTITY_ADAPT) return target;
365         target = filterValue(target,
366                         MethodHandles.identity(target.varType()), MethodHandles.identity(target.varType()));
367         MethodType mtype = target.accessModeType(VarHandle.AccessMode.GET);
368         for (int i = 0 ; i < mtype.parameterCount() ; i++) {
369             target = filterCoordinates(target, i, MethodHandles.identity(mtype.parameterType(i)));
370         }
371         return target;
372     }
373 
374     public static VarHandle filterValue(VarHandle target, MethodHandle pFilterToTarget, MethodHandle pFilterFromTarget) {
375         Objects.requireNonNull(target);
376         Objects.requireNonNull(pFilterToTarget);
377         Objects.requireNonNull(pFilterFromTarget);
378         //check that from/to filters do not throw checked exceptions
379         MethodHandle filterToTarget = adaptForCheckedExceptions(pFilterToTarget);
380         MethodHandle filterFromTarget = adaptForCheckedExceptions(pFilterFromTarget);
381 
382         List<Class<?>> newCoordinates = new ArrayList<>();
383         List<Class<?>> additionalCoordinates = new ArrayList<>();
384         newCoordinates.addAll(target.coordinateTypes());
385 
386         //check that from/to filters have right signatures
387         if (filterFromTarget.type().parameterCount() != filterToTarget.type().parameterCount()) {
388             throw newIllegalArgumentException("filterFromTarget and filterToTarget have different arity", filterFromTarget.type(), filterToTarget.type());
389         } else if (filterFromTarget.type().parameterCount() < 1) {
390             throw newIllegalArgumentException("filterFromTarget filter type has wrong arity", filterFromTarget.type());
391         } else if (filterToTarget.type().parameterCount() < 1) {
392             throw newIllegalArgumentException("filterToTarget filter type has wrong arity", filterFromTarget.type());
393         } else if (filterFromTarget.type().lastParameterType() != filterToTarget.type().returnType() ||
394                 filterToTarget.type().lastParameterType() != filterFromTarget.type().returnType()) {
395             throw newIllegalArgumentException("filterFromTarget and filterToTarget filter types do not match", filterFromTarget.type(), filterToTarget.type());
396         } else if (target.varType() != filterFromTarget.type().lastParameterType()) {
397             throw newIllegalArgumentException("filterFromTarget filter type does not match target var handle type", filterFromTarget.type(), target.varType());
398         } else if (target.varType() != filterToTarget.type().returnType()) {
399             throw newIllegalArgumentException("filterFromTarget filter type does not match target var handle type", filterToTarget.type(), target.varType());
400         } else if (filterFromTarget.type().parameterCount() > 1) {
401             for (int i = 0 ; i < filterFromTarget.type().parameterCount() - 1 ; i++) {
402                 if (filterFromTarget.type().parameterType(i) != filterToTarget.type().parameterType(i)) {
403                     throw newIllegalArgumentException("filterFromTarget and filterToTarget filter types do not match", filterFromTarget.type(), filterToTarget.type());
404                 } else {
405                     newCoordinates.add(filterFromTarget.type().parameterType(i));
406                     additionalCoordinates.add((filterFromTarget.type().parameterType(i)));
407                 }
408             }
409         }
410 
411         return new IndirectVarHandle(target, filterFromTarget.type().returnType(), newCoordinates.toArray(new Class<?>[0]),
412                 (mode, modeHandle) -> {
413                     int lastParameterPos = modeHandle.type().parameterCount() - 1;
414                     return switch (mode.at) {
415                         case GET -> MethodHandles.collectReturnValue(modeHandle, filterFromTarget);
416                         case SET -> MethodHandles.collectArguments(modeHandle, lastParameterPos, filterToTarget);
417                         case GET_AND_UPDATE -> {
418                             MethodHandle adapter = MethodHandles.collectReturnValue(modeHandle, filterFromTarget);
419                             MethodHandle res = MethodHandles.collectArguments(adapter, lastParameterPos, filterToTarget);
420                             if (additionalCoordinates.size() > 0) {
421                                 res = joinDuplicateArgs(res, lastParameterPos,
422                                         lastParameterPos + additionalCoordinates.size() + 1,
423                                         additionalCoordinates.size());
424                             }
425                             yield res;
426                         }
427                         case COMPARE_AND_EXCHANGE -> {
428                             MethodHandle adapter = MethodHandles.collectReturnValue(modeHandle, filterFromTarget);
429                             adapter = MethodHandles.collectArguments(adapter, lastParameterPos, filterToTarget);
430                             if (additionalCoordinates.size() > 0) {
431                                 adapter = joinDuplicateArgs(adapter, lastParameterPos,
432                                         lastParameterPos + additionalCoordinates.size() + 1,
433                                         additionalCoordinates.size());
434                             }
435                             MethodHandle res = MethodHandles.collectArguments(adapter, lastParameterPos - 1, filterToTarget);
436                             if (additionalCoordinates.size() > 0) {
437                                 res = joinDuplicateArgs(res, lastParameterPos - 1,
438                                         lastParameterPos + additionalCoordinates.size(),
439                                         additionalCoordinates.size());
440                             }
441                             yield res;
442                         }
443                         case COMPARE_AND_SET -> {
444                             MethodHandle adapter = MethodHandles.collectArguments(modeHandle, lastParameterPos, filterToTarget);
445                             MethodHandle res = MethodHandles.collectArguments(adapter, lastParameterPos - 1, filterToTarget);
446                             if (additionalCoordinates.size() > 0) {
447                                 res = joinDuplicateArgs(res, lastParameterPos - 1,
448                                         lastParameterPos + additionalCoordinates.size(),
449                                         additionalCoordinates.size());
450                             }
451                             yield res;
452                         }
453                     };
454                 });
455     }
456 
457     private static MethodHandle joinDuplicateArgs(MethodHandle handle, int originalStart, int dropStart, int length) {
458         int[] perms = new int[handle.type().parameterCount()];
459         for (int i = 0 ; i < dropStart; i++) {
460             perms[i] = i;
461         }
462         for (int i = 0 ; i < length ; i++) {
463             perms[dropStart + i] = originalStart + i;
464         }
465         for (int i = dropStart + length ; i < perms.length ; i++) {
466             perms[i] = i - length;
467         }
468         return MethodHandles.permuteArguments(handle,
469                 handle.type().dropParameterTypes(dropStart, dropStart + length),
470                 perms);
471     }
472 
473     public static VarHandle filterCoordinates(VarHandle target, int pos, MethodHandle... filters) {
474         Objects.requireNonNull(target);
475         Objects.requireNonNull(filters);
476 
477         List<Class<?>> targetCoordinates = target.coordinateTypes();
478         if (pos < 0 || pos >= targetCoordinates.size()) {
479             throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
480         } else if (pos + filters.length > targetCoordinates.size()) {
481             throw new IllegalArgumentException("Too many filters");
482         }
483 
484         if (filters.length == 0) return target;
485 
486         List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
487         for (int i = 0 ; i < filters.length ; i++) {
488             MethodHandle filter = Objects.requireNonNull(filters[i]);
489             filter = adaptForCheckedExceptions(filter);
490             MethodType filterType = filter.type();
491             if (filterType.parameterCount() != 1) {
492                 throw newIllegalArgumentException("Invalid filter type " + filterType);
493             } else if (newCoordinates.get(pos + i) != filterType.returnType()) {
494                 throw newIllegalArgumentException("Invalid filter type " + filterType + " for coordinate type " + newCoordinates.get(i));
495             }
496             newCoordinates.set(pos + i, filters[i].type().parameterType(0));
497         }
498 
499         return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
500                 (mode, modeHandle) -> MethodHandles.filterArguments(modeHandle, 1 + pos, filters));
501     }
502 
503     public static VarHandle insertCoordinates(VarHandle target, int pos, Object... values) {
504         Objects.requireNonNull(target);
505         Objects.requireNonNull(values);
506 
507         List<Class<?>> targetCoordinates = target.coordinateTypes();
508         if (pos < 0 || pos >= targetCoordinates.size()) {
509             throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
510         } else if (pos + values.length > targetCoordinates.size()) {
511             throw new IllegalArgumentException("Too many values");
512         }
513 
514         if (values.length == 0) return target;
515 
516         List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
517         for (int i = 0 ; i < values.length ; i++) {
518             Class<?> pt = newCoordinates.get(pos);
519             if (pt.isPrimitive()) {
520                 Wrapper w = Wrapper.forPrimitiveType(pt);
521                 w.convert(values[i], pt);
522             } else {
523                 pt.cast(values[i]);
524             }
525             newCoordinates.remove(pos);
526         }
527 
528         return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
529                 (mode, modeHandle) -> MethodHandles.insertArguments(modeHandle, 1 + pos, values));
530     }
531 
532     public static VarHandle permuteCoordinates(VarHandle target, List<Class<?>> newCoordinates, int... reorder) {
533         Objects.requireNonNull(target);
534         Objects.requireNonNull(newCoordinates);
535         Objects.requireNonNull(reorder);
536 
537         List<Class<?>> targetCoordinates = target.coordinateTypes();
538         MethodHandles.permuteArgumentChecks(reorder,
539                 MethodType.methodType(void.class, newCoordinates),
540                 MethodType.methodType(void.class, targetCoordinates));
541 
542         return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
543                 (mode, modeHandle) ->
544                         MethodHandles.permuteArguments(modeHandle,
545                                 methodTypeFor(mode.at, modeHandle.type(), targetCoordinates, newCoordinates),
546                                 reorderArrayFor(mode.at, newCoordinates, reorder)));
547     }
548 
549     private static int numTrailingArgs(VarHandle.AccessType at) {
550         return switch (at) {
551             case GET -> 0;
552             case GET_AND_UPDATE, SET -> 1;
553             case COMPARE_AND_SET, COMPARE_AND_EXCHANGE -> 2;
554         };
555     }
556 
557     private static int[] reorderArrayFor(VarHandle.AccessType at, List<Class<?>> newCoordinates, int[] reorder) {
558         int numTrailingArgs = numTrailingArgs(at);
559         int[] adjustedReorder = new int[reorder.length + 1 + numTrailingArgs];
560         adjustedReorder[0] = 0;
561         for (int i = 0 ; i < reorder.length ; i++) {
562             adjustedReorder[i + 1] = reorder[i] + 1;
563         }
564         for (int i = 0 ; i < numTrailingArgs ; i++) {
565             adjustedReorder[i + reorder.length + 1] = i + newCoordinates.size() + 1;
566         }
567         return adjustedReorder;
568     }
569 
570     private static MethodType methodTypeFor(VarHandle.AccessType at, MethodType oldType, List<Class<?>> oldCoordinates, List<Class<?>> newCoordinates) {
571         int numTrailingArgs = numTrailingArgs(at);
572         MethodType adjustedType = MethodType.methodType(oldType.returnType(), oldType.parameterType(0));
573         adjustedType = adjustedType.appendParameterTypes(newCoordinates);
574         for (int i = 0 ; i < numTrailingArgs ; i++) {
575             adjustedType = adjustedType.appendParameterTypes(oldType.parameterType(1 + oldCoordinates.size() + i));
576         }
577         return adjustedType;
578     }
579 
580     public static VarHandle collectCoordinates(VarHandle target, int pos, MethodHandle pFilter) {
581         Objects.requireNonNull(target);
582         Objects.requireNonNull(pFilter);
583         MethodHandle filter = adaptForCheckedExceptions(pFilter);
584 
585         List<Class<?>> targetCoordinates = target.coordinateTypes();
586         if (pos < 0 || pos >= targetCoordinates.size()) {
587             throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
588         } else if (filter.type().returnType() == void.class) {
589             throw newIllegalArgumentException("Invalid filter type " + filter.type() + " ; filter cannot be void");
590         } else if (filter.type().returnType() != targetCoordinates.get(pos)) {
591             throw newIllegalArgumentException("Invalid filter type " + filter.type() + " for coordinate type " + targetCoordinates.get(pos));
592         }
593 
594         List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
595         newCoordinates.remove(pos);
596         newCoordinates.addAll(pos, filter.type().parameterList());
597 
598         return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
599                 (mode, modeHandle) -> MethodHandles.collectArguments(modeHandle, 1 + pos, filter));
600     }
601 
602     public static VarHandle dropCoordinates(VarHandle target, int pos, Class<?>... valueTypes) {
603         Objects.requireNonNull(target);
604         Objects.requireNonNull(valueTypes);
605 
606         List<Class<?>> targetCoordinates = target.coordinateTypes();
607         if (pos < 0 || pos > targetCoordinates.size()) {
608             throw newIllegalArgumentException("Invalid position " + pos + " for coordinate types", targetCoordinates);
609         }
610 
611         if (valueTypes.length == 0) return target;
612 
613         List<Class<?>> newCoordinates = new ArrayList<>(targetCoordinates);
614         newCoordinates.addAll(pos, List.of(valueTypes));
615 
616         return new IndirectVarHandle(target, target.varType(), newCoordinates.toArray(new Class<?>[0]),
617                 (mode, modeHandle) -> MethodHandles.dropArguments(modeHandle, 1 + pos, valueTypes));
618     }
619 
620     private static MethodHandle adaptForCheckedExceptions(MethodHandle target) {
621         Class<?>[] exceptionTypes = exceptionTypes(target);
622         if (exceptionTypes != null) { // exceptions known
623             if (Stream.of(exceptionTypes).anyMatch(VarHandles::isCheckedException)) {
624                 throw newIllegalArgumentException("Cannot adapt a var handle with a method handle which throws checked exceptions");
625             }
626             return target; // no adaptation needed
627         } else {
628             MethodHandle handler = MethodHandleImpl.getConstantHandle(MethodHandleImpl.MH_VarHandles_handleCheckedExceptions);
629             MethodHandle zero = MethodHandles.zero(target.type().returnType()); // dead branch
630             handler = MethodHandles.collectArguments(zero, 0, handler);
631             return MethodHandles.catchException(target, Throwable.class, handler);
632         }
633     }
634 
635     static void handleCheckedExceptions(Throwable throwable) throws Throwable {
636         if (isCheckedException(throwable.getClass())) {
637             throw new IllegalStateException("Adapter handle threw checked exception", throwable);
638         }
639         throw throwable;
640     }
641 
642     static Class<?>[] exceptionTypes(MethodHandle handle) {
643         if (handle instanceof DirectMethodHandle directHandle) {
644             byte refKind = directHandle.member.getReferenceKind();
645             MethodHandleInfo info = new InfoFromMemberName(
646                     MethodHandles.Lookup.IMPL_LOOKUP,
647                     directHandle.member,
648                     refKind);
649             if (MethodHandleNatives.refKindIsMethod(refKind)) {
650                 return info.reflectAs(Method.class, MethodHandles.Lookup.IMPL_LOOKUP)
651                         .getExceptionTypes();
652             } else if (MethodHandleNatives.refKindIsField(refKind)) {
653                 return new Class<?>[0];
654             } else if (MethodHandleNatives.refKindIsObjectConstructor(refKind)) {
655                 return info.reflectAs(Constructor.class, MethodHandles.Lookup.IMPL_LOOKUP)
656                         .getExceptionTypes();
657             } else {
658                 throw new AssertionError("Cannot get here");
659             }
660         } else if (handle instanceof DelegatingMethodHandle) {
661             return exceptionTypes(((DelegatingMethodHandle)handle).getTarget());
662         } else if (handle instanceof NativeMethodHandle) {
663             return new Class<?>[0];
664         }
665 
666         assert handle instanceof BoundMethodHandle : "Unexpected handle type: " + handle;
667         // unknown
668         return null;
669     }
670 
671     private static boolean isCheckedException(Class<?> clazz) {
672         return Throwable.class.isAssignableFrom(clazz) &&
673                 !RuntimeException.class.isAssignableFrom(clazz) &&
674                 !Error.class.isAssignableFrom(clazz);
675     }
676 
677 //    /**
678 //     * A helper program to generate the VarHandleGuards class with a set of
679 //     * static guard methods each of which corresponds to a particular shape and
680 //     * performs a type check of the symbolic type descriptor with the VarHandle
681 //     * type descriptor before linking/invoking to the underlying operation as
682 //     * characterized by the operation member name on the VarForm of the
683 //     * VarHandle.
684 //     * <p>
685 //     * The generated class essentially encapsulates pre-compiled LambdaForms,
686 //     * one for each method, for the most set of common method signatures.
687 //     * This reduces static initialization costs, footprint costs, and circular
688 //     * dependencies that may arise if a class is generated per LambdaForm.
689 //     * <p>
690 //     * A maximum of L*T*S methods will be generated where L is the number of
691 //     * access modes kinds (or unique operation signatures) and T is the number
692 //     * of variable types and S is the number of shapes (such as instance field,
693 //     * static field, or array access).
694 //     * If there are 4 unique operation signatures, 5 basic types (Object, int,
695 //     * long, float, double), and 3 shapes then a maximum of 60 methods will be
696 //     * generated.  However, the number is likely to be less since there
697 //     * be duplicate signatures.
698 //     * <p>
699 //     * Each method is annotated with @LambdaForm.Compiled to inform the runtime
700 //     * that such methods should be treated as if a method of a class that is the
701 //     * result of compiling a LambdaForm.  Annotation of such methods is
702 //     * important for correct evaluation of certain assertions and method return
703 //     * type profiling in HotSpot.
704 //     */
705 //    public static class GuardMethodGenerator {
706 //
707 //        static final String GUARD_METHOD_SIG_TEMPLATE = "<RETURN> <NAME>_<SIGNATURE>(<PARAMS>)";
708 //
709 //        static final String GUARD_METHOD_TEMPLATE =
710 //                """
711 //                @ForceInline
712 //                @LambdaForm.Compiled
713 //                @Hidden
714 //                static final <METHOD> throws Throwable {
715 //                    handle.checkExactAccessMode(ad);
716 //                    if (handle.isDirect() && handle.vform.methodType_table[ad.type] == ad.symbolicMethodTypeErased) {
717 //                        <RESULT_ERASED>MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);<RETURN_ERASED>
718 //                    } else {
719 //                        MethodHandle mh = handle.getMethodHandle(ad.mode);
720 //                        <RETURN>mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);
721 //                    }
722 //                }""";
723 //
724 //        static final String GUARD_METHOD_TEMPLATE_V =
725 //                """
726 //                @ForceInline
727 //                @LambdaForm.Compiled
728 //                @Hidden
729 //                static final <METHOD> throws Throwable {
730 //                    handle.checkExactAccessMode(ad);
731 //                    if (handle.isDirect() && handle.vform.methodType_table[ad.type] == ad.symbolicMethodTypeErased) {
732 //                        MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);
733 //                    } else if (handle.isDirect() && handle.vform.getMethodType_V(ad.type) == ad.symbolicMethodTypeErased) {
734 //                        MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);
735 //                    } else {
736 //                        MethodHandle mh = handle.getMethodHandle(ad.mode);
737 //                        mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);
738 //                    }
739 //                }""";
740 //
741 //        // A template for deriving the operations
742 //        // could be supported by annotating VarHandle directly with the
743 //        // operation kind and shape
744 //        interface VarHandleTemplate {
745 //            Object get();
746 //
747 //            void set(Object value);
748 //
749 //            boolean compareAndSet(Object actualValue, Object expectedValue);
750 //
751 //            Object compareAndExchange(Object actualValue, Object expectedValue);
752 //
753 //            Object getAndUpdate(Object value);
754 //        }
755 //
756 //        static class HandleType {
757 //            final Class<?> receiver;
758 //            final Class<?>[] intermediates;
759 //            final Class<?> value;
760 //
761 //            HandleType(Class<?> receiver, Class<?> value, Class<?>... intermediates) {
762 //                this.receiver = receiver;
763 //                this.intermediates = intermediates;
764 //                this.value = value;
765 //            }
766 //        }
767 //
768 //        /**
769 //         * @param args parameters
770 //         */
771 //        public static void main(String[] args) {
772 //            System.out.println("package java.lang.invoke;");
773 //            System.out.println();
774 //            System.out.println("import jdk.internal.vm.annotation.ForceInline;");
775 //            System.out.println("import jdk.internal.vm.annotation.Hidden;");
776 //            System.out.println();
777 //            System.out.println("// This class is auto-generated by " +
778 //                               GuardMethodGenerator.class.getName() +
779 //                               ". Do not edit.");
780 //            System.out.println("final class VarHandleGuards {");
781 //
782 //            System.out.println();
783 //
784 //            // Declare the stream of shapes
785 //            Stream<HandleType> hts = Stream.of(
786 //                    // Object->Object
787 //                    new HandleType(Object.class, Object.class),
788 //                    // Object->int
789 //                    new HandleType(Object.class, int.class),
790 //                    // Object->long
791 //                    new HandleType(Object.class, long.class),
792 //                    // Object->float
793 //                    new HandleType(Object.class, float.class),
794 //                    // Object->double
795 //                    new HandleType(Object.class, double.class),
796 //
797 //                    // <static>->Object
798 //                    new HandleType(null, Object.class),
799 //                    // <static>->int
800 //                    new HandleType(null, int.class),
801 //                    // <static>->long
802 //                    new HandleType(null, long.class),
803 //                    // <static>->float
804 //                    new HandleType(null, float.class),
805 //                    // <static>->double
806 //                    new HandleType(null, double.class),
807 //
808 //                    // Array[int]->Object
809 //                    new HandleType(Object.class, Object.class, int.class),
810 //                    // Array[int]->int
811 //                    new HandleType(Object.class, int.class, int.class),
812 //                    // Array[int]->long
813 //                    new HandleType(Object.class, long.class, int.class),
814 //                    // Array[int]->float
815 //                    new HandleType(Object.class, float.class, int.class),
816 //                    // Array[int]->double
817 //                    new HandleType(Object.class, double.class, int.class),
818 //
819 //                    // Array[long]->int
820 //                    new HandleType(Object.class, int.class, long.class),
821 //                    // Array[long]->long
822 //                    new HandleType(Object.class, long.class, long.class)
823 //            );
824 //
825 //            hts.flatMap(ht -> Stream.of(VarHandleTemplate.class.getMethods()).
826 //                    map(m -> generateMethodType(m, ht.receiver, ht.value, ht.intermediates))).
827 //                    distinct().
828 //                    map(GuardMethodGenerator::generateMethod).
829 //                    forEach(System.out::println);
830 //
831 //            System.out.println("}");
832 //        }
833 //
834 //        static MethodType generateMethodType(Method m, Class<?> receiver, Class<?> value, Class<?>... intermediates) {
835 //            Class<?> returnType = m.getReturnType() == Object.class
836 //                                  ? value : m.getReturnType();
837 //
838 //            List<Class<?>> params = new ArrayList<>();
839 //            if (receiver != null)
840 //                params.add(receiver);
841 //            for (int i = 0; i < intermediates.length; i++) {
842 //                params.add(intermediates[i]);
843 //            }
844 //            for (Parameter p : m.getParameters()) {
845 //                params.add(value);
846 //            }
847 //            return MethodType.methodType(returnType, params);
848 //        }
849 //
850 //        static String generateMethod(MethodType mt) {
851 //            Class<?> returnType = mt.returnType();
852 //
853 //            LinkedHashMap<String, Class<?>> params = new LinkedHashMap<>();
854 //            params.put("handle", VarHandle.class);
855 //            for (int i = 0; i < mt.parameterCount(); i++) {
856 //                params.put("arg" + i, mt.parameterType(i));
857 //            }
858 //            params.put("ad", VarHandle.AccessDescriptor.class);
859 //
860 //            // Generate method signature line
861 //            String RETURN = className(returnType);
862 //            String NAME = "guard";
863 //            String SIGNATURE = getSignature(mt);
864 //            String PARAMS = params.entrySet().stream().
865 //                    map(e -> className(e.getValue()) + " " + e.getKey()).
866 //                    collect(joining(", "));
867 //            String METHOD = GUARD_METHOD_SIG_TEMPLATE.
868 //                    replace("<RETURN>", RETURN).
869 //                    replace("<NAME>", NAME).
870 //                    replace("<SIGNATURE>", SIGNATURE).
871 //                    replace("<PARAMS>", PARAMS);
872 //
873 //            // Generate method
874 //            params.remove("ad");
875 //
876 //            List<String> LINK_TO_STATIC_ARGS = params.keySet().stream().
877 //                    collect(toList());
878 //            LINK_TO_STATIC_ARGS.add("handle.vform.getMemberName(ad.mode)");
879 //            List<String> LINK_TO_STATIC_ARGS_V = params.keySet().stream().
880 //                    collect(toList());
881 //            LINK_TO_STATIC_ARGS_V.add("handle.vform.getMemberName_V(ad.mode)");
882 //
883 //            List<String> LINK_TO_INVOKER_ARGS = params.keySet().stream().
884 //                    collect(toList());
885 //            LINK_TO_INVOKER_ARGS.set(0, LINK_TO_INVOKER_ARGS.get(0) + ".asDirect()");
886 //
887 //            RETURN = returnType == void.class
888 //                     ? ""
889 //                     : returnType == Object.class
890 //                       ? "return "
891 //                       : "return (" + returnType.getName() + ") ";
892 //
893 //            String RESULT_ERASED = returnType == void.class
894 //                                   ? ""
895 //                                   : returnType != Object.class
896 //                                     ? "return (" + returnType.getName() + ") "
897 //                                     : "Object r = ";
898 //
899 //            String RETURN_ERASED = returnType != Object.class
900 //                                   ? ""
901 //                                   : "\n        return ad.returnType.cast(r);";
902 //
903 //            String template = returnType == void.class
904 //                              ? GUARD_METHOD_TEMPLATE_V
905 //                              : GUARD_METHOD_TEMPLATE;
906 //            return template.
907 //                    replace("<METHOD>", METHOD).
908 //                    replace("<NAME>", NAME).
909 //                    replaceAll("<RETURN>", RETURN).
910 //                    replace("<RESULT_ERASED>", RESULT_ERASED).
911 //                    replace("<RETURN_ERASED>", RETURN_ERASED).
912 //                    replaceAll("<LINK_TO_STATIC_ARGS>", LINK_TO_STATIC_ARGS.stream().
913 //                            collect(joining(", "))).
914 //                    replaceAll("<LINK_TO_STATIC_ARGS_V>", LINK_TO_STATIC_ARGS_V.stream().
915 //                            collect(joining(", "))).
916 //                    replace("<LINK_TO_INVOKER_ARGS>", LINK_TO_INVOKER_ARGS.stream().
917 //                            collect(joining(", ")))
918 //                    .indent(4);
919 //        }
920 //
921 //        static String className(Class<?> c) {
922 //            String n = c.getName();
923 //            if (n.startsWith("java.lang.")) {
924 //                n = n.replace("java.lang.", "");
925 //                if (n.startsWith("invoke.")) {
926 //                    n = n.replace("invoke.", "");
927 //                }
928 //            }
929 //            return n.replace('$', '.');
930 //        }
931 //
932 //        static String getSignature(MethodType m) {
933 //            StringBuilder sb = new StringBuilder(m.parameterCount() + 1);
934 //
935 //            for (int i = 0; i < m.parameterCount(); i++) {
936 //                Class<?> pt = m.parameterType(i);
937 //                sb.append(getCharType(pt));
938 //            }
939 //
940 //            sb.append('_').append(getCharType(m.returnType()));
941 //
942 //            return sb.toString();
943 //        }
944 //
945 //        static char getCharType(Class<?> pt) {
946 //            if (pt == void.class) {
947 //                return 'V';
948 //            }
949 //            else if (!pt.isPrimitive()) {
950 //                return 'L';
951 //            }
952 //            else if (pt == boolean.class) {
953 //                return 'Z';
954 //            }
955 //            else if (pt == int.class) {
956 //                return 'I';
957 //            }
958 //            else if (pt == long.class) {
959 //                return 'J';
960 //            }
961 //            else if (pt == float.class) {
962 //                return 'F';
963 //            }
964 //            else if (pt == double.class) {
965 //                return 'D';
966 //            }
967 //            else {
968 //                throw new IllegalStateException(pt.getName());
969 //            }
970 //        }
971 //    }
972 }