diff --git a/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java b/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java index 47b15d44993..17cb85a5f3e 100644 --- a/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java +++ b/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java @@ -1632,6 +1632,11 @@ abstract class MethodHandleImpl { return IMPL_LOOKUP.unreflectConstructor(ctor); } + @Override + public MethodHandle unreflectField(Field field, boolean isSetter) throws IllegalAccessException { + return isSetter ? IMPL_LOOKUP.unreflectSetter(field) : IMPL_LOOKUP.unreflectGetter(field); + } + @Override public VarHandle unreflectVarHandle(Field field) throws IllegalAccessException { return IMPL_LOOKUP.unreflectVarHandle(field); diff --git a/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java b/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java index d9146c5cc64..c445172f348 100644 --- a/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java +++ b/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java @@ -149,11 +149,14 @@ public interface JavaLangInvokeAccess { */ MethodHandle unreflectConstructor(Constructor ctor) throws IllegalAccessException; + /** + * Produces a method handle unreflecting from a {@code Field} with + * the trusted lookup + */ + MethodHandle unreflectField(Field field, boolean isSetter) throws IllegalAccessException; + /** * Produces a var handle unreflecting from a {@code Field} with the trusted lookup. - * @param field - * @return - * @throws IllegalAccessException */ VarHandle unreflectVarHandle(Field field) throws IllegalAccessException; diff --git a/src/java.base/share/classes/jdk/internal/reflect/MethodHandleAccessorFactory.java b/src/java.base/share/classes/jdk/internal/reflect/MethodHandleAccessorFactory.java index 1c8d66e9749..a8c72edb998 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/MethodHandleAccessorFactory.java +++ b/src/java.base/share/classes/jdk/internal/reflect/MethodHandleAccessorFactory.java @@ -140,26 +140,28 @@ final class MethodHandleAccessorFactory { try { // the declaring class of the field has been initialized - var varHandle = JLIA.unreflectVarHandle(field); + // var varHandle = JLIA.unreflectVarHandle(field); + var getter = JLIA.unreflectField(field, false); + var setter = isReadOnly ? null : JLIA.unreflectField(field, true); Class type = field.getType(); if (type == Boolean.TYPE) { - return VarHandleBooleanFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleBooleanFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else if (type == Byte.TYPE) { - return VarHandleByteFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleByteFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else if (type == Short.TYPE) { - return VarHandleShortFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleShortFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else if (type == Character.TYPE) { - return VarHandleCharacterFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleCharacterFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else if (type == Integer.TYPE) { - return VarHandleIntegerFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleIntegerFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else if (type == Long.TYPE) { - return VarHandleLongFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleLongFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else if (type == Float.TYPE) { - return VarHandleFloatFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleFloatFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else if (type == Double.TYPE) { - return VarHandleDoubleFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleDoubleFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } else { - return VarHandleObjectFieldAccessorImpl.fieldAccessor(field, varHandle, isReadOnly); + return VarHandleObjectFieldAccessorImpl.fieldAccessor(field, getter, setter, isReadOnly); } } catch (IllegalAccessException e) { throw new InternalError(e); diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleBooleanFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleBooleanFieldAccessorImpl.java index c1da1a01ff0..4e5429a5ca3 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleBooleanFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleBooleanFieldAccessorImpl.java @@ -25,50 +25,34 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; +import java.lang.reflect.Method; import java.lang.reflect.Modifier; -abstract class VarHandleBooleanFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleBooleanFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract boolean getValue(Object obj); - abstract void setValue(Object obj, boolean z) throws Throwable; - - static class StaticFieldAccessor extends VarHandleBooleanFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - boolean getValue(Object obj) { - return (boolean) varHandle.get(); - } - - void setValue(Object obj, boolean z) throws Throwable { - varHandle.set(z); +class VarHandleBooleanFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(boolean.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, boolean.class)); + } + } else { + getter = getter.asType(MethodType.methodType(boolean.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, boolean.class)); + } } + return new VarHandleBooleanFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleBooleanFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - boolean getValue(Object obj) { - return (boolean) varHandle.get(obj); - } - - void setValue(Object obj, boolean z) throws Throwable { - varHandle.set(obj, z); - } + VarHandleBooleanFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -78,7 +62,11 @@ abstract class VarHandleBooleanFieldAccessorImpl extends VarHandleFieldAccessorI public boolean getBoolean(Object obj) throws IllegalArgumentException { ensureObj(obj); try { - return getValue(obj); + if (isStatic()) { + return (boolean) getter.invokeExact(); + } else { + return (boolean) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -143,7 +131,11 @@ abstract class VarHandleBooleanFieldAccessorImpl extends VarHandleFieldAccessorI throwFinalFieldIllegalAccessException(z); } try { - setValue(obj, z); + if (isStatic()) { + setter.invokeExact(z); + } else { + setter.invokeExact(obj, z); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleByteFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleByteFieldAccessorImpl.java index ab661cb9556..9ed9a6944d6 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleByteFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleByteFieldAccessorImpl.java @@ -25,50 +25,33 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleByteFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleByteFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract byte getValue(Object obj); - abstract void setValue(Object obj, byte b) throws Throwable; - - static class StaticFieldAccessor extends VarHandleByteFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - byte getValue(Object obj) { - return (byte) varHandle.get(); - } - - void setValue(Object obj, byte b) throws Throwable { - varHandle.set(b); +class VarHandleByteFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(byte.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, byte.class)); + } + } else { + getter = getter.asType(MethodType.methodType(byte.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, byte.class)); + } } + return new VarHandleByteFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleByteFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - byte getValue(Object obj) { - return (byte) varHandle.get(obj); - } - - void setValue(Object obj, byte b) throws Throwable { - varHandle.set(obj, b); - } + VarHandleByteFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -81,7 +64,11 @@ abstract class VarHandleByteFieldAccessorImpl extends VarHandleFieldAccessorImpl public byte getByte(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + if (isStatic()) { + return (byte) getter.invokeExact(); + } else { + return (byte) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -148,7 +135,11 @@ abstract class VarHandleByteFieldAccessorImpl extends VarHandleFieldAccessorImpl throwFinalFieldIllegalAccessException(b); } try { - setValue(obj, b); + if (isStatic()) { + setter.invokeExact(b); + } else { + setter.invokeExact(obj, b); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleCharacterFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleCharacterFieldAccessorImpl.java index faf09422740..3e2a7aabe4d 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleCharacterFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleCharacterFieldAccessorImpl.java @@ -25,50 +25,33 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleCharacterFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleCharacterFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract char getValue(Object obj); - abstract void setValue(Object obj, char c) throws Throwable; - - static class StaticFieldAccessor extends VarHandleCharacterFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - char getValue(Object obj) { - return (char) varHandle.get(); - } - - void setValue(Object obj, char c) throws Throwable { - varHandle.set(c); +class VarHandleCharacterFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(char.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, char.class)); + } + } else { + getter = getter.asType(MethodType.methodType(char.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, char.class)); + } } + return new VarHandleCharacterFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleCharacterFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - char getValue(Object obj) { - return (char) varHandle.get(obj); - } - - void setValue(Object obj, char c) throws Throwable { - varHandle.set(obj, c); - } + VarHandleCharacterFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -85,7 +68,11 @@ abstract class VarHandleCharacterFieldAccessorImpl extends VarHandleFieldAccesso public char getChar(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + if (isStatic()) { + return (char) getter.invokeExact(); + } else { + return (char) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -154,7 +141,11 @@ abstract class VarHandleCharacterFieldAccessorImpl extends VarHandleFieldAccesso throwFinalFieldIllegalAccessException(c); } try { - setValue(obj, c); + if (isStatic()) { + setter.invokeExact(c); + } else { + setter.invokeExact(obj, c); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleDoubleFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleDoubleFieldAccessorImpl.java index d1450e55957..fe64818105d 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleDoubleFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleDoubleFieldAccessorImpl.java @@ -25,50 +25,33 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleDoubleFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleDoubleFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract double getValue(Object obj); - abstract void setValue(Object obj, double d) throws Throwable; - - static class StaticFieldAccessor extends VarHandleDoubleFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - double getValue(Object obj) { - return (double) varHandle.get(); - } - - void setValue(Object obj, double d) throws Throwable { - varHandle.set(d); +class VarHandleDoubleFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(double.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, double.class)); + } + } else { + getter = getter.asType(MethodType.methodType(double.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, double.class)); + } } + return new VarHandleDoubleFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleDoubleFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - double getValue(Object obj) { - return (double) varHandle.get(obj); - } - - void setValue(Object obj, double d) throws Throwable { - varHandle.set(obj, d); - } + VarHandleDoubleFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -105,7 +88,11 @@ abstract class VarHandleDoubleFieldAccessorImpl extends VarHandleFieldAccessorIm public double getDouble(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + if (isStatic()) { + return (double) getter.invokeExact(); + } else { + return (double) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -203,7 +190,11 @@ abstract class VarHandleDoubleFieldAccessorImpl extends VarHandleFieldAccessorIm throwFinalFieldIllegalAccessException(d); } try { - setValue(obj, d); + if (isStatic()) { + setter.invokeExact(d); + } else { + setter.invokeExact(obj, d); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleFieldAccessorImpl.java index 844d7f38ae0..61315b48dae 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleFieldAccessorImpl.java @@ -27,6 +27,7 @@ package jdk.internal.reflect; import jdk.internal.vm.annotation.Stable; +import java.lang.invoke.MethodHandle; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; @@ -36,22 +37,29 @@ abstract class VarHandleFieldAccessorImpl extends FieldAccessorImpl { private static final int NONZERO_BIT = 0x8000; private @Stable final int fieldFlags; - protected @Stable final VarHandle varHandle; + // protected @Stable final VarHandle varHandle; + protected @Stable final MethodHandle getter; + protected @Stable final MethodHandle setter; - protected VarHandleFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { + protected VarHandleFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { super(field); this.fieldFlags = (isReadOnly ? IS_READ_ONLY_BIT : 0) | (isStatic ? IS_STATIC_BIT : 0) | NONZERO_BIT; - this.varHandle = varHandle; + this.getter = getter; + this.setter = setter; } protected final boolean isReadOnly() { return (fieldFlags & IS_READ_ONLY_BIT) == IS_READ_ONLY_BIT; } + protected final boolean isStatic() { + return (fieldFlags & IS_STATIC_BIT) == IS_STATIC_BIT; + } + protected final void ensureObj(Object o) { - if ((fieldFlags & IS_STATIC_BIT) == 0) { + if (!isStatic()) { // for compatibility, check the receiver object first // throw NullPointerException if o is null if (!field.getDeclaringClass().isAssignableFrom(o.getClass())) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleFloatFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleFloatFieldAccessorImpl.java index 52c3a7df57c..af44b20af8d 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleFloatFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleFloatFieldAccessorImpl.java @@ -25,50 +25,33 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleFloatFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleFloatFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract float getValue(Object obj); - abstract void setValue(Object obj, float f) throws Throwable; - - static class StaticFieldAccessor extends VarHandleFloatFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - float getValue(Object obj) { - return (float) varHandle.get(); - } - - void setValue(Object obj, float f) throws Throwable { - varHandle.set(f); +class VarHandleFloatFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(float.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, float.class)); + } + } else { + getter = getter.asType(MethodType.methodType(float.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, float.class)); + } } + return new VarHandleFloatFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleFloatFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - float getValue(Object obj) { - return (float) varHandle.get(obj); - } - - void setValue(Object obj, float f) throws Throwable { - varHandle.set(obj, f); - } + VarHandleFloatFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -101,7 +84,11 @@ abstract class VarHandleFloatFieldAccessorImpl extends VarHandleFieldAccessorImp public float getFloat(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + if (isStatic()) { + return (float) getter.invokeExact(); + } else { + return (float) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -194,7 +181,11 @@ abstract class VarHandleFloatFieldAccessorImpl extends VarHandleFieldAccessorImp throwFinalFieldIllegalAccessException(f); } try { - setValue(obj, f); + if (isStatic()) { + setter.invokeExact(f); + } else { + setter.invokeExact(obj, f); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleIntegerFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleIntegerFieldAccessorImpl.java index 7c38f0ac2db..244c67e8825 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleIntegerFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleIntegerFieldAccessorImpl.java @@ -25,50 +25,33 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleIntegerFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleIntegerFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract int getValue(Object obj); - abstract void setValue(Object obj, int i) throws Throwable; - - static class StaticFieldAccessor extends VarHandleIntegerFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - int getValue(Object obj) { - return (int) varHandle.get(); - } - - void setValue(Object obj, int i) throws Throwable { - varHandle.set(i); +class VarHandleIntegerFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(int.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, int.class)); + } + } else { + getter = getter.asType(MethodType.methodType(int.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, int.class)); + } } + return new VarHandleIntegerFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleIntegerFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - int getValue(Object obj) { - return (int) varHandle.get(obj); - } - - void setValue(Object obj, int i) throws Throwable { - varHandle.set(obj, i); - } + VarHandleIntegerFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -93,7 +76,11 @@ abstract class VarHandleIntegerFieldAccessorImpl extends VarHandleFieldAccessorI public int getInt(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + if (isStatic()) { + return (int) getter.invokeExact(); + } else { + return (int) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -176,7 +163,11 @@ abstract class VarHandleIntegerFieldAccessorImpl extends VarHandleFieldAccessorI throwFinalFieldIllegalAccessException(i); } try { - setValue(obj, i); + if (isStatic()) { + setter.invokeExact(i); + } else { + setter.invokeExact(obj, i); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleLongFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleLongFieldAccessorImpl.java index 56d98d9da5e..ce90e821a29 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleLongFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleLongFieldAccessorImpl.java @@ -25,50 +25,33 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleLongFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleLongFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract long getValue(Object obj); - abstract void setValue(Object obj, long l) throws Throwable; - - static class StaticFieldAccessor extends VarHandleLongFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - long getValue(Object obj) { - return (long) varHandle.get(); - } - - void setValue(Object obj, long l) throws Throwable { - varHandle.set(l); +class VarHandleLongFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(long.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, long.class)); + } + } else { + getter = getter.asType(MethodType.methodType(long.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, long.class)); + } } + return new VarHandleLongFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleLongFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - long getValue(Object obj) { - return (long) varHandle.get(obj); - } - - void setValue(Object obj, long l) throws Throwable { - varHandle.set(obj, l); - } + VarHandleLongFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -97,7 +80,11 @@ abstract class VarHandleLongFieldAccessorImpl extends VarHandleFieldAccessorImpl public long getLong(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + if (isStatic()) { + return (long) getter.invokeExact(); + } else { + return (long) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -185,7 +172,11 @@ abstract class VarHandleLongFieldAccessorImpl extends VarHandleFieldAccessorImpl throwFinalFieldIllegalAccessException(l); } try { - setValue(obj, l); + if (isStatic()) { + setter.invokeExact(l); + } else { + setter.invokeExact(obj, l); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleObjectFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleObjectFieldAccessorImpl.java index 0a51e1c22c7..18d8a65225d 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleObjectFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleObjectFieldAccessorImpl.java @@ -25,57 +25,53 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleObjectFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); +class VarHandleObjectFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class)); + } + } else { + getter = getter.asType(MethodType.methodType(Object.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, Object.class)); + } + } + return new VarHandleObjectFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - VarHandleObjectFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); + VarHandleObjectFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } - abstract Object getValue(Object obj); - abstract void setValue(Object obj, Object value) throws Throwable; - - static class StaticFieldAccessor extends VarHandleObjectFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - Object getValue(Object obj) { - return varHandle.get(); - } - - void setValue(Object obj, Object value) throws Throwable { - varHandle.set(value); - } + @ForceInline + Object getValue(Object obj) throws Throwable { + return isStatic() ? getter.invokeExact() : getter.invokeExact(obj); } - static class InstanceFieldAccessor extends VarHandleObjectFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - Object getValue(Object obj) { - return varHandle.get(obj); + @ForceInline + void setValue(Object obj, Object value) throws Throwable { + if (isStatic()) { + setter.invokeExact(value); + } else { + setter.invokeExact(obj, value); } - - void setValue(Object obj, Object value) throws Throwable { - varHandle.set(obj, value); - } - } @Override public Object get(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + return isStatic() ? getter.invokeExact() : getter.invokeExact(obj); } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -124,7 +120,11 @@ abstract class VarHandleObjectFieldAccessorImpl extends VarHandleFieldAccessorIm throwFinalFieldIllegalAccessException(value); } try { - setValue(obj, value); + if (isStatic()) { + setter.invokeExact(value); + } else { + setter.invokeExact(obj, value); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { diff --git a/src/java.base/share/classes/jdk/internal/reflect/VarHandleShortFieldAccessorImpl.java b/src/java.base/share/classes/jdk/internal/reflect/VarHandleShortFieldAccessorImpl.java index 1f2b1f60ef6..9121b303bd1 100644 --- a/src/java.base/share/classes/jdk/internal/reflect/VarHandleShortFieldAccessorImpl.java +++ b/src/java.base/share/classes/jdk/internal/reflect/VarHandleShortFieldAccessorImpl.java @@ -25,50 +25,33 @@ package jdk.internal.reflect; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodType; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Modifier; -abstract class VarHandleShortFieldAccessorImpl extends VarHandleFieldAccessorImpl { - static FieldAccessorImpl fieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - return Modifier.isStatic(field.getModifiers()) - ? new StaticFieldAccessor(field, varHandle, isReadOnly) - : new InstanceFieldAccessor(field, varHandle, isReadOnly); - } - - VarHandleShortFieldAccessorImpl(Field field, VarHandle varHandle, boolean isReadOnly, boolean isStatic) { - super(field, varHandle, isReadOnly, isStatic); - } - - abstract short getValue(Object obj); - abstract void setValue(Object obj, short s) throws Throwable; - - static class StaticFieldAccessor extends VarHandleShortFieldAccessorImpl { - StaticFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, true); - } - - short getValue(Object obj) { - return (short) varHandle.get(); - } - - void setValue(Object obj, short s) throws Throwable { - varHandle.set(s); +class VarHandleShortFieldAccessorImpl extends VarHandleFieldAccessorImpl { + static FieldAccessorImpl fieldAccessor(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly) { + boolean isStatic = Modifier.isStatic(field.getModifiers()); + if (isStatic) { + getter = getter.asType(MethodType.methodType(short.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, short.class)); + } + } else { + getter = getter.asType(MethodType.methodType(short.class, Object.class)); + if (setter != null) { + setter = setter.asType(MethodType.methodType(void.class, Object.class, short.class)); + } } + return new VarHandleShortFieldAccessorImpl(field, getter, setter, isReadOnly, isStatic); } - static class InstanceFieldAccessor extends VarHandleShortFieldAccessorImpl { - InstanceFieldAccessor(Field field, VarHandle varHandle, boolean isReadOnly) { - super(field, varHandle, isReadOnly, false); - } - - short getValue(Object obj) { - return (short) varHandle.get(obj); - } - - void setValue(Object obj, short s) throws Throwable { - varHandle.set(obj, s); - } + VarHandleShortFieldAccessorImpl(Field field, MethodHandle getter, MethodHandle setter, boolean isReadOnly, boolean isStatic) { + super(field, getter, setter, isReadOnly, isStatic); } public Object get(Object obj) throws IllegalArgumentException { @@ -89,7 +72,11 @@ abstract class VarHandleShortFieldAccessorImpl extends VarHandleFieldAccessorImp public short getShort(Object obj) throws IllegalArgumentException { try { - return getValue(obj); + if (isStatic()) { + return (short) getter.invokeExact(); + } else { + return (short) getter.invokeExact(obj); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) { @@ -164,7 +151,11 @@ abstract class VarHandleShortFieldAccessorImpl extends VarHandleFieldAccessorImp throwFinalFieldIllegalAccessException(s); } try { - setValue(obj, s); + if (isStatic()) { + setter.invokeExact(s); + } else { + setter.invokeExact(obj, s); + } } catch (IllegalArgumentException|NullPointerException e) { throw e; } catch (ClassCastException e) {