1538 SharedSecrets.setJavaLangInvokeAccess(new JavaLangInvokeAccess() {
1539 @Override
1540 public Class<?> getDeclaringClass(Object rmname) {
1541 ResolvedMethodName method = (ResolvedMethodName)rmname;
1542 return method.declaringClass();
1543 }
1544
1545 @Override
1546 public MethodType getMethodType(String descriptor, ClassLoader loader) {
1547 return MethodType.fromDescriptor(descriptor, loader);
1548 }
1549
1550 public boolean isCallerSensitive(int flags) {
1551 return (flags & MN_CALLER_SENSITIVE) == MN_CALLER_SENSITIVE;
1552 }
1553
1554 public boolean isHiddenMember(int flags) {
1555 return (flags & MN_HIDDEN_MEMBER) == MN_HIDDEN_MEMBER;
1556 }
1557
1558 @Override
1559 public Map<String, byte[]> generateHolderClasses(Stream<String> traces) {
1560 return GenerateJLIClassesHelper.generateHolderClasses(traces);
1561 }
1562
1563 @Override
1564 public VarHandle memorySegmentViewHandle(Class<?> carrier, MemoryLayout enclosing, long alignmentMask, ByteOrder order, boolean constantOffset, long offset) {
1565 return VarHandles.memorySegmentViewHandle(carrier, enclosing, alignmentMask, constantOffset, offset, order);
1566 }
1567
1568 @Override
1569 public MethodHandle nativeMethodHandle(NativeEntryPoint nep) {
1570 return NativeMethodHandle.make(nep);
1571 }
1572
1573 @Override
1574 public VarHandle filterValue(VarHandle target, MethodHandle filterToTarget, MethodHandle filterFromTarget) {
1575 return VarHandles.filterValue(target, filterToTarget, filterFromTarget);
1576 }
1577
1628 return null;
1629 }
1630 }
1631
1632 @Override
1633 public MethodHandle reflectiveInvoker(Class<?> caller) {
1634 Objects.requireNonNull(caller);
1635 return BindCaller.reflectiveInvoker(caller);
1636 }
1637
1638 @Override
1639 public Class<?>[] exceptionTypes(MethodHandle handle) {
1640 return VarHandles.exceptionTypes(handle);
1641 }
1642
1643 @Override
1644 public MethodHandle serializableConstructor(Class<?> decl, Constructor<?> ctorToCall) throws IllegalAccessException {
1645 return IMPL_LOOKUP.serializableConstructor(decl, ctorToCall);
1646 }
1647
1648 });
1649 }
1650
1651 /** Result unboxing: ValueConversions.unbox() OR ValueConversions.identity() OR ValueConversions.ignore(). */
1652 private static MethodHandle unboxResultHandle(Class<?> returnType) {
1653 if (returnType.isPrimitive()) {
1654 if (returnType == void.class) {
1655 return ValueConversions.ignore();
1656 } else {
1657 Wrapper w = Wrapper.forPrimitiveType(returnType);
1658 return ValueConversions.unboxExact(w);
1659 }
1660 } else {
1661 return MethodHandles.identity(Object.class);
1662 }
1663 }
1664
1665 /**
1666 * Assembles a loop method handle from the given handles and type information.
1667 *
|
1538 SharedSecrets.setJavaLangInvokeAccess(new JavaLangInvokeAccess() {
1539 @Override
1540 public Class<?> getDeclaringClass(Object rmname) {
1541 ResolvedMethodName method = (ResolvedMethodName)rmname;
1542 return method.declaringClass();
1543 }
1544
1545 @Override
1546 public MethodType getMethodType(String descriptor, ClassLoader loader) {
1547 return MethodType.fromDescriptor(descriptor, loader);
1548 }
1549
1550 public boolean isCallerSensitive(int flags) {
1551 return (flags & MN_CALLER_SENSITIVE) == MN_CALLER_SENSITIVE;
1552 }
1553
1554 public boolean isHiddenMember(int flags) {
1555 return (flags & MN_HIDDEN_MEMBER) == MN_HIDDEN_MEMBER;
1556 }
1557
1558 public boolean isNullRestrictedField(MethodHandle mh) {
1559 var memberName = mh.internalMemberName();
1560 return memberName.isNullRestricted();
1561 }
1562
1563 @Override
1564 public Map<String, byte[]> generateHolderClasses(Stream<String> traces) {
1565 return GenerateJLIClassesHelper.generateHolderClasses(traces);
1566 }
1567
1568 @Override
1569 public VarHandle memorySegmentViewHandle(Class<?> carrier, MemoryLayout enclosing, long alignmentMask, ByteOrder order, boolean constantOffset, long offset) {
1570 return VarHandles.memorySegmentViewHandle(carrier, enclosing, alignmentMask, constantOffset, offset, order);
1571 }
1572
1573 @Override
1574 public MethodHandle nativeMethodHandle(NativeEntryPoint nep) {
1575 return NativeMethodHandle.make(nep);
1576 }
1577
1578 @Override
1579 public VarHandle filterValue(VarHandle target, MethodHandle filterToTarget, MethodHandle filterFromTarget) {
1580 return VarHandles.filterValue(target, filterToTarget, filterFromTarget);
1581 }
1582
1633 return null;
1634 }
1635 }
1636
1637 @Override
1638 public MethodHandle reflectiveInvoker(Class<?> caller) {
1639 Objects.requireNonNull(caller);
1640 return BindCaller.reflectiveInvoker(caller);
1641 }
1642
1643 @Override
1644 public Class<?>[] exceptionTypes(MethodHandle handle) {
1645 return VarHandles.exceptionTypes(handle);
1646 }
1647
1648 @Override
1649 public MethodHandle serializableConstructor(Class<?> decl, Constructor<?> ctorToCall) throws IllegalAccessException {
1650 return IMPL_LOOKUP.serializableConstructor(decl, ctorToCall);
1651 }
1652
1653 @Override
1654 public MethodHandle assertAsType(MethodHandle original, MethodType assertedType) {
1655 return original.viewAsType(assertedType, false);
1656 }
1657 });
1658 }
1659
1660 /** Result unboxing: ValueConversions.unbox() OR ValueConversions.identity() OR ValueConversions.ignore(). */
1661 private static MethodHandle unboxResultHandle(Class<?> returnType) {
1662 if (returnType.isPrimitive()) {
1663 if (returnType == void.class) {
1664 return ValueConversions.ignore();
1665 } else {
1666 Wrapper w = Wrapper.forPrimitiveType(returnType);
1667 return ValueConversions.unboxExact(w);
1668 }
1669 } else {
1670 return MethodHandles.identity(Object.class);
1671 }
1672 }
1673
1674 /**
1675 * Assembles a loop method handle from the given handles and type information.
1676 *
|