stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8298177: Various java.lang.invoke cleanups

Browse Source 
8284363: Redundant imports in BoundMethodHandle

Reviewed-by: jvernee
This commit is contained in:
Claes Redestad 2022-12-07 15:37:58 +00:00
parent 6ed36835ec
commit 3de775094d
11 changed files with 80 additions and 375 deletions

29
src/java.base/share/classes/java/lang/invoke/BoundMethodHandle.java

@ -26,16 +26,12 @@
package java.lang.invoke;
import jdk.internal.vm.annotation.Stable;
import sun.invoke.util.ValueConversions;
import java.util.ArrayList;
import java.util.List;
import static java.lang.invoke.LambdaForm.BasicType;
import static java.lang.invoke.LambdaForm.BasicType.*;
import static java.lang.invoke.LambdaForm.BasicType.V_TYPE_NUM;
import static java.lang.invoke.LambdaForm.BasicType.V_TYPE_NUM;
import static java.lang.invoke.LambdaForm.BasicType.V_TYPE_NUM;
import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
import static java.lang.invoke.MethodHandleNatives.Constants.*;
import static java.lang.invoke.MethodHandleStatics.newInternalError;
@ -61,22 +57,6 @@ abstract non-sealed class BoundMethodHandle extends MethodHandle {
// BMH API and internals
//
static BoundMethodHandle bindSingle(MethodType type, LambdaForm form, BasicType xtype, Object x) {
// for some type signatures, there exist pre-defined concrete BMH classes
try {
return switch (xtype) {
case L_TYPE -> bindSingle(type, form, x); // Use known fast path.
case I_TYPE -> (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(I_TYPE_NUM).factory().invokeBasic(type, form, ValueConversions.widenSubword(x));
case J_TYPE -> (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(J_TYPE_NUM).factory().invokeBasic(type, form, (long) x);
case F_TYPE -> (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(F_TYPE_NUM).factory().invokeBasic(type, form, (float) x);
case D_TYPE -> (BoundMethodHandle) SPECIALIZER.topSpecies().extendWith(D_TYPE_NUM).factory().invokeBasic(type, form, (double) x);
default -> throw newInternalError("unexpected xtype: " + xtype);
};
} catch (Throwable t) {
throw uncaughtException(t);
}
}
/*non-public*/
LambdaFormEditor editor() {
return form.editor();
@ -356,15 +336,16 @@ abstract non-sealed class BoundMethodHandle extends MethodHandle {
private boolean verifyTHAargs(MemberName transform, int whichtm, List<?> args, List<?> fields) {
assert(transform == Specializer.BMH_TRANSFORMS.get(whichtm));
assert(args.size() == transform.getMethodType().parameterCount());
MethodType tType = transform.getMethodType();
assert(args.size() == tType.parameterCount());
assert(fields.size() == this.fieldCount());
final int MH_AND_LF = 2;
if (whichtm == Specializer.TN_COPY_NO_EXTEND) {
assert(transform.getMethodType().parameterCount() == MH_AND_LF);
assert(tType.parameterCount() == MH_AND_LF);
} else if (whichtm < ARG_TYPE_LIMIT) {
assert(transform.getMethodType().parameterCount() == MH_AND_LF+1);
assert(tType.parameterCount() == MH_AND_LF+1);
final BasicType type = basicType((byte) whichtm);
assert(transform.getParameterTypes()[MH_AND_LF] == type.basicTypeClass());
assert(tType.parameterType(MH_AND_LF) == type.basicTypeClass());
} else {
return false;
}

7
src/java.base/share/classes/java/lang/invoke/ClassSpecializer.java

@ -328,12 +328,13 @@ abstract class ClassSpecializer<T,K,S extends ClassSpecializer<T,K,S>.SpeciesDat
private final MethodType transformHelperType(int whichtm) {
MemberName tm = transformMethods().get(whichtm);
MethodType tmt = tm.getMethodType();
ArrayList<Class<?>> args = new ArrayList<>();
ArrayList<Class<?>> fields = new ArrayList<>();
Collections.addAll(args, tm.getParameterTypes());
Collections.addAll(args, tmt.ptypes());
fields.addAll(fieldTypes());
List<Class<?>> helperArgs = deriveTransformHelperArguments(tm, whichtm, args, fields);
return MethodType.methodType(tm.getReturnType(), helperArgs);
return MethodType.methodType(tmt.returnType(), helperArgs);
}
// Hooks for subclasses:
@ -432,7 +433,7 @@ abstract class ClassSpecializer<T,K,S extends ClassSpecializer<T,K,S>.SpeciesDat
final Class<T> topc = topClass();
if (!topClassIsSuper) {
try {
final Constructor<T> con = reflectConstructor(topc, baseConstructorType().parameterArray());
final Constructor<T> con = reflectConstructor(topc, baseConstructorType().ptypes());
if (!topc.isInterface() && !Modifier.isPrivate(con.getModifiers())) {
topClassIsSuper = true;
}

2
src/java.base/share/classes/java/lang/invoke/DirectMethodHandle.java

@ -600,7 +600,7 @@ sealed class DirectMethodHandle extends MethodHandle {
}
Object checkCast(Object obj) {
return member.getReturnType().cast(obj);
return member.getMethodType().returnType().cast(obj);
}
// Caching machinery for field accessors:

2
src/java.base/share/classes/java/lang/invoke/InvokerBytecodeGenerator.java

@ -1043,7 +1043,7 @@ class InvokerBytecodeGenerator {
private static boolean isStaticallyInvocableType(MethodType mtype) {
if (!isStaticallyNameable(mtype.returnType()))
return false;
for (Class<?> ptype : mtype.parameterArray())
for (Class<?> ptype : mtype.ptypes())
if (!isStaticallyNameable(ptype))
return false;
return true;

30
src/java.base/share/classes/java/lang/invoke/LambdaForm.java

@ -364,16 +364,6 @@ class LambdaForm {
this(arity, names, LAST_RESULT, forceInline, /*customized=*/null, kind);
}
private static Name[] buildNames(Name[] formals, Name[] temps, Name result) {
int arity = formals.length;
int length = arity + temps.length + (result == null ? 0 : 1);
Name[] names = Arrays.copyOf(formals, length);
System.arraycopy(temps, 0, names, arity, temps.length);
if (result != null)
names[length - 1] = result;
return names;
}
private LambdaForm(MethodType mt) {
// Make a blank lambda form, which returns a constant zero or null.
// It is used as a template for managing the invocation of similar forms that are non-empty.
@ -1338,13 +1328,15 @@ class LambdaForm {
final Object constraint; // additional type information, if not null
@Stable final Object[] arguments;
private static final Object[] EMPTY_ARGS = new Object[0];
private Name(int index, BasicType type, NamedFunction function, Object[] arguments) {
this.index = (short)index;
this.type = type;
this.function = function;
this.arguments = arguments;
this.constraint = null;
assert(this.index == index);
assert(this.index == index && typesMatch(function, this.arguments));
}
private Name(Name that, Object constraint) {
this.index = that.index;
@ -1365,9 +1357,17 @@ class LambdaForm {
Name(MemberName function, Object... arguments) {
this(new NamedFunction(function), arguments);
}
Name(NamedFunction function) {
this(-1, function.returnType(), function, EMPTY_ARGS);
}
Name(NamedFunction function, Object arg) {
this(-1, function.returnType(), function, new Object[] { arg });
}
Name(NamedFunction function, Object arg0, Object arg1) {
this(-1, function.returnType(), function, new Object[] { arg0, arg1 });
}
Name(NamedFunction function, Object... arguments) {
this(-1, function.returnType(), function, arguments = Arrays.copyOf(arguments, arguments.length, Object[].class));
assert(typesMatch(function, arguments));
this(-1, function.returnType(), function, Arrays.copyOf(arguments, arguments.length, Object[].class));
}
/** Create a raw parameter of the given type, with an expected index. */
Name(int index, BasicType type) {
@ -1534,6 +1534,10 @@ class LambdaForm {
}
private boolean typesMatch(NamedFunction function, Object ... arguments) {
if (arguments == null) {
assert(function == null);
return true;
}
assert(arguments.length == function.arity()) : "arity mismatch: arguments.length=" + arguments.length + " == function.arity()=" + function.arity() + " in " + debugString();
for (int i = 0; i < arguments.length; i++) {
assert (typesMatch(function.parameterType(i), arguments[i])) : "types don't match: function.parameterType(" + i + ")=" + function.parameterType(i) + ", arguments[" + i + "]=" + arguments[i] + " in " + debugString();

279
src/java.base/share/classes/java/lang/invoke/MemberName.java

@ -25,7 +25,6 @@
package java.lang.invoke;
import sun.invoke.util.BytecodeDescriptor;
import sun.invoke.util.VerifyAccess;
import java.lang.reflect.Constructor;
@ -33,10 +32,6 @@ import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import static java.lang.invoke.MethodHandleNatives.Constants.*;
@ -74,7 +69,7 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError;
final class ResolvedMethodName {
//@Injected JVM_Method* vmtarget;
//@Injected Class<?> vmholder;
};
}
/*non-public*/
final class MemberName implements Member, Cloneable {
@ -198,16 +193,6 @@ final class MemberName implements Member, Cloneable {
return itype;
}
/** Utility method producing the parameter types of the method type. */
public Class<?>[] getParameterTypes() {
return getMethodType().parameterArray();
}
/** Utility method producing the return type of the method type. */
public Class<?> getReturnType() {
return getMethodType().returnType();
}
/** Return the declared type of this member, which
* must be a field or type.
* If it is a type member, that type itself is returned.
@ -249,22 +234,6 @@ final class MemberName implements Member, Cloneable {
return (isInvocable() ? getMethodType() : getFieldType());
}
/** Utility method to produce the signature of this member,
* used within the class file format to describe its type.
*/
public String getSignature() {
if (type == null) {
expandFromVM();
if (type == null) {
return null;
}
}
if (isInvocable())
return BytecodeDescriptor.unparse(getMethodType());
else
return BytecodeDescriptor.unparse(getFieldType());
}
/** Return the modifier flags of this member.
* @see java.lang.reflect.Modifier
*/
@ -356,20 +325,19 @@ final class MemberName implements Member, Cloneable {
}
private MemberName changeReferenceKind(byte refKind, byte oldKind) {
assert(getReferenceKind() == oldKind);
assert(MethodHandleNatives.refKindIsValid(refKind));
assert(getReferenceKind() == oldKind && MethodHandleNatives.refKindIsValid(refKind));
flags += (((int)refKind - oldKind) << MN_REFERENCE_KIND_SHIFT);
return this;
}
private boolean testFlags(int mask, int value) {
return (flags & mask) == value;
private boolean matchingFlagsSet(int mask, int flags) {
return (this.flags & mask) == flags;
}
private boolean testAllFlags(int mask) {
return testFlags(mask, mask);
private boolean allFlagsSet(int flags) {
return (this.flags & flags) == flags;
}
private boolean testAnyFlags(int mask) {
return !testFlags(mask, 0);
private boolean anyFlagSet(int flags) {
return (this.flags & flags) != 0;
}
/** Utility method to query if this member is a method handle invocation (invoke or invokeExact).
@ -377,26 +345,21 @@ final class MemberName implements Member, Cloneable {
public boolean isMethodHandleInvoke() {
final int bits = MH_INVOKE_MODS &~ Modifier.PUBLIC;
final int negs = Modifier.STATIC;
if (testFlags(bits | negs, bits) &&
clazz == MethodHandle.class) {
if (matchingFlagsSet(bits | negs, bits) && clazz == MethodHandle.class) {
return isMethodHandleInvokeName(name);
}
return false;
}
public static boolean isMethodHandleInvokeName(String name) {
switch (name) {
case "invoke":
case "invokeExact":
return true;
default:
return false;
}
return switch (name) {
case "invoke", "invokeExact" -> true;
default -> false;
};
}
public boolean isVarHandleMethodInvoke() {
final int bits = MH_INVOKE_MODS &~ Modifier.PUBLIC;
final int negs = Modifier.STATIC;
if (testFlags(bits | negs, bits) &&
clazz == VarHandle.class) {
if (matchingFlagsSet(bits | negs, bits) && clazz == VarHandle.class) {
return isVarHandleMethodInvokeName(name);
}
return false;
@ -457,15 +420,15 @@ final class MemberName implements Member, Cloneable {
static final int ENUM = 0x00004000;
/** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
public boolean isBridge() {
return testAllFlags(IS_METHOD | BRIDGE);
return allFlagsSet(IS_METHOD | BRIDGE);
}
/** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
public boolean isVarargs() {
return testAllFlags(VARARGS) && isInvocable();
return allFlagsSet(VARARGS) && isInvocable();
}
/** Utility method to query the modifier flags of this member; returns false if the member is not a method. */
public boolean isSynthetic() {
return testAllFlags(SYNTHETIC);
return allFlagsSet(SYNTHETIC);
}
static final String CONSTRUCTOR_NAME = "<init>"; // the ever-popular
@ -485,49 +448,38 @@ final class MemberName implements Member, Cloneable {
static final int ALL_ACCESS = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED;
static final int ALL_KINDS = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE;
static final int IS_INVOCABLE = IS_METHOD | IS_CONSTRUCTOR;
static final int IS_FIELD_OR_METHOD = IS_METHOD | IS_FIELD;
static final int SEARCH_ALL_SUPERS = MN_SEARCH_SUPERCLASSES | MN_SEARCH_INTERFACES;
/** Utility method to query whether this member is a method or constructor. */
public boolean isInvocable() {
return testAnyFlags(IS_INVOCABLE);
}
/** Utility method to query whether this member is a method, constructor, or field. */
public boolean isFieldOrMethod() {
return testAnyFlags(IS_FIELD_OR_METHOD);
return anyFlagSet(IS_INVOCABLE);
}
/** Query whether this member is a method. */
public boolean isMethod() {
return testAllFlags(IS_METHOD);
return allFlagsSet(IS_METHOD);
}
/** Query whether this member is a constructor. */
public boolean isConstructor() {
return testAllFlags(IS_CONSTRUCTOR);
return allFlagsSet(IS_CONSTRUCTOR);
}
/** Query whether this member is a field. */
public boolean isField() {
return testAllFlags(IS_FIELD);
return allFlagsSet(IS_FIELD);
}
/** Query whether this member is a type. */
public boolean isType() {
return testAllFlags(IS_TYPE);
return allFlagsSet(IS_TYPE);
}
/** Utility method to query whether this member is neither public, private, nor protected. */
public boolean isPackage() {
return !testAnyFlags(ALL_ACCESS);
return !anyFlagSet(ALL_ACCESS);
}
/** Query whether this member has a CallerSensitive annotation. */
public boolean isCallerSensitive() {
return testAllFlags(CALLER_SENSITIVE);
return allFlagsSet(CALLER_SENSITIVE);
}
/** Query whether this member is a trusted final field. */
public boolean isTrustedFinalField() { return testAllFlags(TRUSTED_FINAL|IS_FIELD); }
/** Utility method to query whether this member is accessible from a given lookup class. */
public boolean isAccessibleFrom(Class<?> lookupClass) {
int mode = (ALL_ACCESS|MethodHandles.Lookup.PACKAGE|MethodHandles.Lookup.MODULE);
return VerifyAccess.isMemberAccessible(this.getDeclaringClass(), this.getDeclaringClass(), flags,
lookupClass, null, mode);
public boolean isTrustedFinalField() {
return allFlagsSet(TRUSTED_FINAL | IS_FIELD);
}
/**
@ -547,8 +499,7 @@ final class MemberName implements Member, Cloneable {
this.name = name;
this.type = type;
this.flags = flags;
assert(testAnyFlags(ALL_KINDS));
assert(this.resolution == null); // nobody should have touched this yet
assert(anyFlagSet(ALL_KINDS) && this.resolution == null); // nobody should have touched this yet
//assert(referenceKindIsConsistent()); // do this after resolution
}
@ -568,9 +519,9 @@ final class MemberName implements Member, Cloneable {
// Capturing information from the Core Reflection API:
private static int flagsMods(int flags, int mods, byte refKind) {
assert((flags & RECOGNIZED_MODIFIERS) == 0);
assert((mods & ~RECOGNIZED_MODIFIERS) == 0);
assert((refKind & ~MN_REFERENCE_KIND_MASK) == 0);
assert((flags & RECOGNIZED_MODIFIERS) == 0
&& (mods & ~RECOGNIZED_MODIFIERS) == 0
&& (refKind & ~MN_REFERENCE_KIND_MASK) == 0);
return flags | mods | (refKind << MN_REFERENCE_KIND_SHIFT);
}
/** Create a name for the given reflected method. The resulting name will be in a resolved state. */
@ -607,7 +558,7 @@ final class MemberName implements Member, Cloneable {
}
throw new LinkageError(m.toString());
}
assert(isResolved() && this.clazz != null);
assert(isResolved());
this.name = m.getName();
if (this.type == null)
this.type = new Object[] { m.getReturnType(), m.getParameterTypes() };
@ -649,20 +600,16 @@ final class MemberName implements Member, Cloneable {
* undoes that change under the assumption that it occurred.)
*/
public MemberName asNormalOriginal() {
byte normalVirtual = clazz.isInterface() ? REF_invokeInterface : REF_invokeVirtual;
byte refKind = getReferenceKind();
byte newRefKind = refKind;
MemberName result = this;
switch (refKind) {
case REF_invokeInterface:
case REF_invokeVirtual:
case REF_invokeSpecial:
newRefKind = normalVirtual;
break;
}
byte newRefKind = switch (refKind) {
case REF_invokeInterface,
REF_invokeVirtual,
REF_invokeSpecial -> clazz.isInterface() ? REF_invokeInterface : REF_invokeVirtual;
default -> refKind;
};
if (newRefKind == refKind)
return this;
result = clone().changeReferenceKind(newRefKind, refKind);
MemberName result = clone().changeReferenceKind(newRefKind, refKind);
assert(this.referenceKindIsConsistentWith(result.getReferenceKind()));
return result;
}
@ -682,6 +629,10 @@ final class MemberName implements Member, Cloneable {
public MemberName(Field fld) {
this(fld, false);
}
static {
// the following MemberName constructor relies on these ranges matching up
assert((REF_putStatic - REF_getStatic) == (REF_putField - REF_getField));
}
@SuppressWarnings("LeakingThisInConstructor")
public MemberName(Field fld, boolean makeSetter) {
Objects.requireNonNull(fld);
@ -690,7 +641,6 @@ final class MemberName implements Member, Cloneable {
assert(isResolved() && this.clazz != null);
this.name = fld.getName();
this.type = fld.getType();
assert((REF_putStatic - REF_getStatic) == (REF_putField - REF_getField));
byte refKind = this.getReferenceKind();
assert(refKind == (isStatic() ? REF_getStatic : REF_getField));
if (makeSetter) {
@ -703,13 +653,7 @@ final class MemberName implements Member, Cloneable {
public boolean isSetter() {
return MethodHandleNatives.refKindIsSetter(getReferenceKind());
}
public MemberName asSetter() {
byte refKind = getReferenceKind();
assert(MethodHandleNatives.refKindIsGetter(refKind));
assert((REF_putStatic - REF_getStatic) == (REF_putField - REF_getField));
byte setterRefKind = (byte)(refKind + (REF_putField - REF_getField));
return clone().changeReferenceKind(setterRefKind, refKind);
}
/** Create a name for the given class. The resulting name will be in a resolved state. */
public MemberName(Class<?> type) {
init(type.getDeclaringClass(), type.getSimpleName(), type,
@ -844,11 +788,6 @@ final class MemberName implements Member, Cloneable {
init(defClass, name, type, flagsMods(kindFlags, 0, refKind));
initResolved(false);
}
/** Query whether this member name is resolved to a non-static, non-final method.
*/
public boolean hasReceiverTypeDispatch() {
return MethodHandleNatives.refKindDoesDispatch(getReferenceKind());
}
/** Query whether this member name is resolved.
* A resolved member name is one for which the JVM has found
@ -930,7 +869,7 @@ final class MemberName implements Member, Cloneable {
}
public IllegalAccessException makeAccessException(String message, Object from) {
message = message + ": "+ toString();
message = message + ": " + this;
if (from != null) {
if (from == MethodHandles.publicLookup()) {
message += ", from public Lookup";
@ -965,7 +904,7 @@ final class MemberName implements Member, Cloneable {
return "no such field";
}
public ReflectiveOperationException makeAccessException() {
String message = message() + ": "+ toString();
String message = message() + ": " + this;
ReflectiveOperationException ex;
if (isResolved() || !(resolution instanceof NoSuchMethodError ||
resolution instanceof NoSuchFieldError))
@ -992,70 +931,8 @@ final class MemberName implements Member, Cloneable {
/*non-public*/
static class Factory {
private Factory() { } // singleton pattern
static Factory INSTANCE = new Factory();
static final Factory INSTANCE = new Factory();
private static int ALLOWED_FLAGS = ALL_KINDS;
/// Queries
List<MemberName> getMembers(Class<?> defc,
String matchName, Object matchType,
int matchFlags, Class<?> lookupClass) {
matchFlags &= ALLOWED_FLAGS;
String matchSig = null;
if (matchType != null) {
matchSig = BytecodeDescriptor.unparse(matchType);
if (matchSig.startsWith("("))
matchFlags &= ~(ALL_KINDS & ~IS_INVOCABLE);
else
matchFlags &= ~(ALL_KINDS & ~IS_FIELD);
}
final int BUF_MAX = 0x2000;
int len1 = matchName == null ? 10 : matchType == null ? 4 : 1;
MemberName[] buf = newMemberBuffer(len1);
int totalCount = 0;
ArrayList<MemberName[]> bufs = null;
int bufCount = 0;
for (;;) {
bufCount = MethodHandleNatives.getMembers(defc,
matchName, matchSig, matchFlags,
lookupClass,
totalCount, buf);
if (bufCount <= buf.length) {
if (bufCount < 0) bufCount = 0;
totalCount += bufCount;
break;
}
// JVM returned to us with an intentional overflow!
totalCount += buf.length;
int excess = bufCount - buf.length;
if (bufs == null) bufs = new ArrayList<>(1);
bufs.add(buf);
int len2 = buf.length;
len2 = Math.max(len2, excess);
len2 = Math.max(len2, totalCount / 4);
buf = newMemberBuffer(Math.min(BUF_MAX, len2));
}
ArrayList<MemberName> result = new ArrayList<>(totalCount);
if (bufs != null) {
for (MemberName[] buf0 : bufs) {
Collections.addAll(result, buf0);
}
}
for (int i = 0; i < bufCount; i++) {
result.add(buf[i]);
}
// Signature matching is not the same as type matching, since
// one signature might correspond to several types.
// So if matchType is a Class or MethodType, refilter the results.
if (matchType != null && matchType != matchSig) {
for (Iterator<MemberName> it = result.iterator(); it.hasNext();) {
MemberName m = it.next();
if (!matchType.equals(m.getType()))
it.remove();
}
}
return result;
}
/** Produce a resolved version of the given member.
* Super types are searched (for inherited members) if {@code searchSupers} is true.
* Access checking is performed on behalf of the given {@code lookupClass}.
@ -1131,69 +1008,5 @@ final class MemberName implements Member, Cloneable {
return result;
return null;
}
/** Return a list of all methods defined by the given class.
* Super types are searched (for inherited members) if {@code searchSupers} is true.
* Access checking is performed on behalf of the given {@code lookupClass}.
* Inaccessible members are not added to the last.
*/
public List<MemberName> getMethods(Class<?> defc, boolean searchSupers,
Class<?> lookupClass) {
return getMethods(defc, searchSupers, null, null, lookupClass);
}
/** Return a list of matching methods defined by the given class.
* Super types are searched (for inherited members) if {@code searchSupers} is true.
* Returned methods will match the name (if not null) and the type (if not null).
* Access checking is performed on behalf of the given {@code lookupClass}.
* Inaccessible members are not added to the last.
*/
public List<MemberName> getMethods(Class<?> defc, boolean searchSupers,
String name, MethodType type, Class<?> lookupClass) {
int matchFlags = IS_METHOD | (searchSupers ? SEARCH_ALL_SUPERS : 0);
return getMembers(defc, name, type, matchFlags, lookupClass);
}
/** Return a list of all constructors defined by the given class.
* Access checking is performed on behalf of the given {@code lookupClass}.
* Inaccessible members are not added to the last.
*/
public List<MemberName> getConstructors(Class<?> defc, Class<?> lookupClass) {
return getMembers(defc, null, null, IS_CONSTRUCTOR, lookupClass);
}
/** Return a list of all fields defined by the given class.
* Super types are searched (for inherited members) if {@code searchSupers} is true.
* Access checking is performed on behalf of the given {@code lookupClass}.
* Inaccessible members are not added to the last.
*/
public List<MemberName> getFields(Class<?> defc, boolean searchSupers,
Class<?> lookupClass) {
return getFields(defc, searchSupers, null, null, lookupClass);
}
/** Return a list of all fields defined by the given class.
* Super types are searched (for inherited members) if {@code searchSupers} is true.
* Returned fields will match the name (if not null) and the type (if not null).
* Access checking is performed on behalf of the given {@code lookupClass}.
* Inaccessible members are not added to the last.
*/
public List<MemberName> getFields(Class<?> defc, boolean searchSupers,
String name, Class<?> type, Class<?> lookupClass) {
int matchFlags = IS_FIELD | (searchSupers ? SEARCH_ALL_SUPERS : 0);
return getMembers(defc, name, type, matchFlags, lookupClass);
}
/** Return a list of all nested types defined by the given class.
* Super types are searched (for inherited members) if {@code searchSupers} is true.
* Access checking is performed on behalf of the given {@code lookupClass}.
* Inaccessible members are not added to the last.
*/
public List<MemberName> getNestedTypes(Class<?> defc, boolean searchSupers,
Class<?> lookupClass) {
int matchFlags = IS_TYPE | (searchSupers ? SEARCH_ALL_SUPERS : 0);
return getMembers(defc, null, null, matchFlags, lookupClass);
}
private static MemberName[] newMemberBuffer(int length) {
MemberName[] buf = new MemberName[length];
// fill the buffer with dummy structs for the JVM to fill in
for (int i = 0; i < length; i++)
buf[i] = new MemberName();
return buf;
}
}
}

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

@ -1005,7 +1005,8 @@ abstract class MethodHandleImpl {
}
static MethodHandle fakeVarHandleInvoke(MemberName method) {
// TODO caching, is it necessary?
MethodType type = MethodType.methodType(method.getReturnType(), UnsupportedOperationException.class,
MethodType type = MethodType.methodType(method.getMethodType().returnType(),
UnsupportedOperationException.class,
VarHandle.class, Object[].class);
MethodHandle mh = throwException(type);
mh = mh.bindTo(new UnsupportedOperationException("cannot reflectively invoke VarHandle"));

2
src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java

@ -64,7 +64,7 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError;
if (isIllegalType(type.returnType()))
return true;
for (Class<?> pType : type.parameterArray()) {
for (Class<?> pType : type.ptypes()) {
if (isIllegalType(pType))
return true;
}

6
src/java.base/share/classes/sun/invoke/util/BytecodeDescriptor.java

@ -113,15 +113,11 @@ public class BytecodeDescriptor {
return type.descriptorString();
}
public static String unparse(MethodType type) {
return unparseMethod(type.returnType(), type.parameterArray());
}
public static String unparse(Object type) {
if (type instanceof Class<?>)
return unparse((Class<?>) type);
if (type instanceof MethodType)
return unparse((MethodType) type);
return ((MethodType) type).toMethodDescriptorString();
return (String) type;
}

71
src/java.base/share/classes/sun/invoke/util/ValueConversions.java

@ -1,5 +1,5 @@
/*
* Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -342,73 +342,13 @@ public class ValueConversions {
// no value to return; this is an unbox of null
}
static void empty() {
}
static Object zeroObject() {
return null;
}
static int zeroInteger() {
return 0;
}
static long zeroLong() {
return 0;
}
static float zeroFloat() {
return 0;
}
static double zeroDouble() {
return 0;
}
private static final WrapperCache[] CONSTANT_FUNCTIONS = newWrapperCaches(2);
public static MethodHandle zeroConstantFunction(Wrapper wrap) {
WrapperCache cache = CONSTANT_FUNCTIONS[0];
MethodHandle mh = cache.get(wrap);
if (mh != null) {
return mh;
}
// slow path
MethodType type = MethodType.methodType(wrap.primitiveType());
switch (wrap) {
case VOID:
mh = Handles.EMPTY;
break;
case OBJECT:
case INT: case LONG: case FLOAT: case DOUBLE:
try {
mh = IMPL_LOOKUP.findStatic(THIS_CLASS, "zero"+wrap.wrapperSimpleName(), type);
} catch (ReflectiveOperationException ex) {
mh = null;
}
break;
}
if (mh != null) {
return cache.put(wrap, mh);
}
// use zeroInt and cast the result
if (wrap.isSubwordOrInt() && wrap != Wrapper.INT) {
mh = MethodHandles.explicitCastArguments(zeroConstantFunction(Wrapper.INT), type);
return cache.put(wrap, mh);
}
throw new IllegalArgumentException("cannot find zero constant for " + wrap);
}
private static class Handles {
static final MethodHandle CAST_REFERENCE, IGNORE, EMPTY;
static final MethodHandle IGNORE;
static {
try {
MethodType idType = MethodType.genericMethodType(1);
MethodType ignoreType = idType.changeReturnType(void.class);
CAST_REFERENCE = IMPL_LOOKUP.findVirtual(Class.class, "cast", idType);
IGNORE = IMPL_LOOKUP.findStatic(THIS_CLASS, "ignore", ignoreType);
EMPTY = IMPL_LOOKUP.findStatic(THIS_CLASS, "empty", ignoreType.dropParameterTypes(0, 1));
} catch (NoSuchMethodException | IllegalAccessException ex) {
throw newInternalError("uncaught exception", ex);
}
@ -419,10 +359,6 @@ public class ValueConversions {
return Handles.IGNORE;
}
/** Return a method that casts its second argument (an Object) to the given type (a Class). */
public static MethodHandle cast() {
return Handles.CAST_REFERENCE;
}
/// Primitive conversions.
// These are supported directly by the JVM, usually by a single instruction.
@ -673,7 +609,4 @@ public class ValueConversions {
private static InternalError newInternalError(String message, Throwable cause) {
return new InternalError(message, cause);
}
private static InternalError newInternalError(Throwable cause) {
return new InternalError(cause);
}
}

24
test/jdk/sun/invoke/util/ValueConversionsTest.java

@ -134,30 +134,6 @@ public class ValueConversionsTest {
}
}
@Test
public void testCast() throws Throwable {
Class<?>[] types = { Object.class, Serializable.class, String.class, Number.class, Integer.class };
Object[] objects = { new Object(), Boolean.FALSE, "hello", (Long)12L, (Integer)6 };
for (Class<?> dst : types) {
MethodHandle caster = ValueConversions.cast().bindTo(dst);
assertEquals(caster.type(), MethodHandles.identity(Object.class).type());
for (Object obj : objects) {
Class<?> src = obj.getClass();
boolean canCast = dst.isAssignableFrom(src);
try {
Object result = caster.invokeExact(obj);
if (canCast)
assertEquals(obj, result);
else
assertEquals("cast should not have succeeded", dst, obj);
} catch (ClassCastException ex) {
if (canCast)
throw ex;
}
}
}
}
@Test
public void testConvert() throws Throwable {
for (long tval = 0, ctr = 0;;) {