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