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