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