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