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