< prev index next >

src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java

Print this page

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      *
< prev index next >