Mercurial > hg > graal-jvmci-8
changeset 23749:d6bd0b9cd0b6
remove uses of setAccessible (JDK-8165434)
line wrap: on
line diff
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java Wed Sep 07 15:17:13 2016 +0200 @@ -26,8 +26,7 @@ import static jdk.vm.ci.common.InitTimer.timer; import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime; -import java.lang.reflect.Constructor; -import java.lang.reflect.Method; +import java.lang.reflect.Executable; import jdk.vm.ci.code.BytecodeFrame; import jdk.vm.ci.code.InstalledCode; @@ -366,10 +365,9 @@ native boolean hasFinalizableSubclass(HotSpotResolvedObjectTypeImpl type); /** - * Gets the method corresponding to {@code holder} and slot number {@code slot} (i.e. - * {@link Method#slot} or {@link Constructor#slot}). + * Gets the method corresponding to {@code executable}. */ - native HotSpotResolvedJavaMethodImpl getResolvedJavaMethodAtSlot(Class<?> holder, int slot); + native HotSpotResolvedJavaMethodImpl asResolvedJavaMethod(Executable executable); /** * Gets the maximum absolute offset of a PC relative call to {@code address} from any position @@ -601,6 +599,12 @@ native int methodDataProfileDataSize(long metaspaceMethodData, int position); /** + * Invokes non-public method {@code java.lang.invoke.LambdaForm.compileToBytecode()} on + * {@code lambdaForm} (which must be a {@code java.lang.invoke.LambdaForm} instance). + */ + native void compileToBytecode(Object lambdaForm); + + /** * Return the amount of native stack required for the interpreter frames represented by * {@code frame}. This is used when emitting the stack banging code to ensure that there is * enough space for the frames during deoptimization.
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotCodeCacheProvider.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotCodeCacheProvider.java Wed Sep 07 15:17:13 2016 +0200 @@ -22,7 +22,7 @@ */ package jdk.vm.ci.hotspot; -import java.lang.reflect.Field; +import java.util.Map; import jdk.vm.ci.code.BailoutException; import jdk.vm.ci.code.BytecodeFrame; @@ -56,16 +56,11 @@ @Override public String getMarkName(Mark mark) { int markId = (int) mark.id; - Field[] fields = runtime.getConfig().getClass().getDeclaredFields(); - for (Field f : fields) { - if (f.getName().startsWith("MARKID_")) { - f.setAccessible(true); - try { - if (f.getInt(runtime.getConfig()) == markId) { - return f.getName(); - } - } catch (Exception e) { - } + HotSpotVMConfigStore store = runtime.getConfigStore(); + for (Map.Entry<String, Long> e : store.getConstants().entrySet()) { + String name = e.getKey(); + if (name.startsWith("MARKID_") && e.getValue() == markId) { + return name; } } return CodeCacheProvider.super.getMarkName(mark); @@ -76,17 +71,13 @@ */ @Override public String getTargetName(Call call) { - Field[] fields = runtime.getConfig().getClass().getDeclaredFields(); - for (Field f : fields) { - if (f.getName().endsWith("Stub")) { - f.setAccessible(true); - Object address; - try { - address = f.get(runtime.getConfig()); - if (address.equals(call.target)) { - return f.getName() + ":0x" + Long.toHexString((Long) address); - } - } catch (IllegalArgumentException | IllegalAccessException e) { + if (call.target instanceof HotSpotForeignCallTarget) { + long address = ((HotSpotForeignCallTarget) call.target).address; + HotSpotVMConfigStore store = runtime.getConfigStore(); + for (Map.Entry<String, VMField> e : store.getFields().entrySet()) { + VMField field = e.getValue(); + if (field.isStatic() && field.value == address) { + return e.getValue() + ":0x" + Long.toHexString(address); } } }
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMetaAccessProvider.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMetaAccessProvider.java Wed Sep 07 15:17:13 2016 +0200 @@ -28,11 +28,10 @@ import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE; import java.lang.reflect.Array; -import java.lang.reflect.Constructor; import java.lang.reflect.Executable; import java.lang.reflect.Field; -import java.lang.reflect.Method; import java.lang.reflect.Modifier; +import java.util.Objects; import jdk.vm.ci.code.CodeUtil; import jdk.vm.ci.code.TargetDescription; @@ -78,35 +77,8 @@ return new HotSpotSignature(runtime, signature); } - /** - * {@link Field} object of {@link Method#slot}. - */ - private Field reflectionMethodSlot = getReflectionSlotField(Method.class); - - /** - * {@link Field} object of {@link Constructor#slot}. - */ - private Field reflectionConstructorSlot = getReflectionSlotField(Constructor.class); - - private static Field getReflectionSlotField(Class<?> reflectionClass) { - try { - Field field = reflectionClass.getDeclaredField("slot"); - field.setAccessible(true); - return field; - } catch (NoSuchFieldException | SecurityException e) { - throw new JVMCIError(e); - } - } - public ResolvedJavaMethod lookupJavaMethod(Executable reflectionMethod) { - try { - Class<?> holder = reflectionMethod.getDeclaringClass(); - Field slotField = reflectionMethod instanceof Constructor ? reflectionConstructorSlot : reflectionMethodSlot; - final int slot = slotField.getInt(reflectionMethod); - return runtime.getCompilerToVM().getResolvedJavaMethodAtSlot(holder, slot); - } catch (IllegalArgumentException | IllegalAccessException e) { - throw new JVMCIError(e); - } + return runtime.getCompilerToVM().asResolvedJavaMethod(Objects.requireNonNull(reflectionMethod)); } public ResolvedJavaField lookupJavaField(Field reflectionField) {
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMethodHandleAccessProvider.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMethodHandleAccessProvider.java Wed Sep 07 15:17:13 2016 +0200 @@ -24,7 +24,10 @@ import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM; import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime; -import static jdk.vm.ci.hotspot.HotSpotResolvedObjectTypeImpl.fromObjectClass; + +import java.lang.invoke.MethodHandle; +import java.util.Objects; + import jdk.vm.ci.common.JVMCIError; import jdk.vm.ci.meta.ConstantReflectionProvider; import jdk.vm.ci.meta.JavaConstant; @@ -46,51 +49,45 @@ * possible after the {@link HotSpotJVMCIRuntime} is fully initialized. */ static class LazyInitialization { + static final ResolvedJavaType lambdaFormType; static final ResolvedJavaField methodHandleFormField; static final ResolvedJavaField lambdaFormVmentryField; - static final ResolvedJavaMethod lambdaFormCompileToBytecodeMethod; static final HotSpotResolvedJavaField memberNameVmtargetField; /** * Search for an instance field with the given name in a class. * - * @param className name of the class to search in + * @param declaringType the type declaring the field * @param fieldName name of the field to be searched * @return resolved java field - * @throws ClassNotFoundException + * @throws NoSuchFieldError */ - private static ResolvedJavaField findFieldInClass(String className, String fieldName) throws ClassNotFoundException { - Class<?> clazz = Class.forName(className); - ResolvedJavaType type = runtime().fromClass(clazz); - ResolvedJavaField[] fields = type.getInstanceFields(false); + private static ResolvedJavaField findFieldInClass(ResolvedJavaType declaringType, String fieldName, ResolvedJavaType fieldType) { + ResolvedJavaField[] fields = declaringType.getInstanceFields(false); for (ResolvedJavaField field : fields) { if (field.getName().equals(fieldName)) { return field; } } - return null; + throw new NoSuchFieldError(fieldType.getName() + " " + declaringType + "." + fieldName); } - private static ResolvedJavaMethod findMethodInClass(String className, String methodName) throws ClassNotFoundException { - Class<?> clazz = Class.forName(className); - HotSpotResolvedObjectTypeImpl type = fromObjectClass(clazz); - ResolvedJavaMethod result = null; - for (ResolvedJavaMethod method : type.getDeclaredMethods()) { - if (method.getName().equals(methodName)) { - assert result == null : "more than one method found: " + className + "." + methodName; - result = method; - } - } - assert result != null : "method not found: " + className + "." + methodName; - return result; + private static ResolvedJavaType resolveType(Class<?> c) { + return runtime().fromClass(c); + } + + private static ResolvedJavaType resolveType(String className) throws ClassNotFoundException { + return resolveType(Class.forName(className)); } static { try { - methodHandleFormField = findFieldInClass("java.lang.invoke.MethodHandle", "form"); - lambdaFormVmentryField = findFieldInClass("java.lang.invoke.LambdaForm", "vmentry"); - lambdaFormCompileToBytecodeMethod = findMethodInClass("java.lang.invoke.LambdaForm", "compileToBytecode"); - memberNameVmtargetField = (HotSpotResolvedJavaField) findFieldInClass("java.lang.invoke.MemberName", "vmtarget"); + ResolvedJavaType methodHandleType = resolveType(MethodHandle.class); + ResolvedJavaType memberNameType = resolveType("java.lang.invoke.MemberName"); + lambdaFormType = resolveType("java.lang.invoke.LambdaForm"); + methodHandleFormField = findFieldInClass(methodHandleType, "form", lambdaFormType); + lambdaFormVmentryField = findFieldInClass(lambdaFormType, "vmentry", memberNameType); + memberNameVmtargetField = (HotSpotResolvedJavaField) findFieldInClass(memberNameType, "vmtarget", resolveType(long.class)); } catch (Throwable ex) { throw new JVMCIError(ex); } @@ -134,13 +131,12 @@ return null; } - JavaConstant memberName; - if (forceBytecodeGeneration) { - /* Invoke non-public method: MemberName LambdaForm.compileToBytecode() */ - memberName = LazyInitialization.lambdaFormCompileToBytecodeMethod.invoke(lambdaForm, new JavaConstant[0]); - } else { - /* Load non-public field: MemberName LambdaForm.vmentry */ + JavaConstant memberName = constantReflection.readFieldValue(LazyInitialization.lambdaFormVmentryField, lambdaForm); + if (memberName.isNull() && forceBytecodeGeneration) { + Object lf = ((HotSpotObjectConstant) lambdaForm).asObject(LazyInitialization.lambdaFormType); + compilerToVM().compileToBytecode(Objects.requireNonNull(lf)); memberName = constantReflection.readFieldValue(LazyInitialization.lambdaFormVmentryField, lambdaForm); + assert memberName.isNonNull(); } return getTargetMethod(memberName); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotModifiers.java Wed Sep 07 15:17:13 2016 +0200 @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2011, 2016, 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 + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package jdk.vm.ci.hotspot; + +import static java.lang.reflect.Modifier.ABSTRACT; +import static java.lang.reflect.Modifier.FINAL; +import static java.lang.reflect.Modifier.INTERFACE; +import static java.lang.reflect.Modifier.NATIVE; +import static java.lang.reflect.Modifier.PRIVATE; +import static java.lang.reflect.Modifier.PROTECTED; +import static java.lang.reflect.Modifier.PUBLIC; +import static java.lang.reflect.Modifier.STATIC; +import static java.lang.reflect.Modifier.STRICT; +import static java.lang.reflect.Modifier.SYNCHRONIZED; +import static java.lang.reflect.Modifier.TRANSIENT; +import static java.lang.reflect.Modifier.VOLATILE; +import static jdk.vm.ci.hotspot.HotSpotVMConfig.config; + +import java.lang.reflect.Modifier; + +/** + * The modifiers not public in {@link Modifier} that need to be retrieved from + * {@link HotSpotVMConfig}. + */ +interface HotSpotModifiers { + + // @formatter:off + int ANNOTATION = config().jvmAccAnnotation; + int ENUM = config().jvmAccEnum; + int VARARGS = config().jvmAccVarargs; + int BRIDGE = config().jvmAccBridge; + int SYNTHETIC = config().jvmAccSynthetic; + // @formatter:on + + static int jvmClassModifiers() { + return PUBLIC | FINAL | INTERFACE | ABSTRACT | ANNOTATION | ENUM | SYNTHETIC; + } + + static int jvmMethodModifiers() { + return PUBLIC | PRIVATE | PROTECTED | STATIC | FINAL | SYNCHRONIZED | BRIDGE | VARARGS | NATIVE | ABSTRACT | STRICT | SYNTHETIC; + } + + static int jvmFieldModifiers() { + return PUBLIC | PRIVATE | PROTECTED | STATIC | FINAL | VOLATILE | TRANSIENT | ENUM | SYNTHETIC; + } +}
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaFieldImpl.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaFieldImpl.java Wed Sep 07 15:17:13 2016 +0200 @@ -22,13 +22,13 @@ */ package jdk.vm.ci.hotspot; +import static jdk.vm.ci.hotspot.HotSpotModifiers.jvmFieldModifiers; import static jdk.vm.ci.hotspot.HotSpotVMConfig.config; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import jdk.vm.ci.meta.JavaType; -import jdk.vm.ci.meta.ModifiersProvider; import jdk.vm.ci.meta.ResolvedJavaType; /** @@ -80,7 +80,7 @@ @Override public int getModifiers() { - return modifiers & ModifiersProvider.jvmFieldModifiers(); + return modifiers & jvmFieldModifiers(); } @Override
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl.java Wed Sep 07 15:17:13 2016 +0200 @@ -24,13 +24,15 @@ import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM; import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime; +import static jdk.vm.ci.hotspot.HotSpotModifiers.BRIDGE; +import static jdk.vm.ci.hotspot.HotSpotModifiers.SYNTHETIC; +import static jdk.vm.ci.hotspot.HotSpotModifiers.VARARGS; +import static jdk.vm.ci.hotspot.HotSpotModifiers.jvmMethodModifiers; import static jdk.vm.ci.hotspot.HotSpotVMConfig.config; import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE; import java.lang.annotation.Annotation; import java.lang.reflect.Executable; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.lang.reflect.Type; import java.util.HashMap; @@ -42,13 +44,11 @@ import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.DefaultProfilingInfo; import jdk.vm.ci.meta.ExceptionHandler; -import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaMethod; import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.LineNumberTable; import jdk.vm.ci.meta.Local; import jdk.vm.ci.meta.LocalVariableTable; -import jdk.vm.ci.meta.ModifiersProvider; import jdk.vm.ci.meta.ProfilingInfo; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -211,7 +211,7 @@ @Override public int getModifiers() { - return getAllModifiers() & ModifiersProvider.jvmMethodModifiers(); + return getAllModifiers() & jvmMethodModifiers(); } @Override @@ -492,6 +492,19 @@ return javaMethod == null ? null : javaMethod.getAnnotation(annotationClass); } + public boolean isBridge() { + return (BRIDGE & getModifiers()) != 0; + } + + @Override + public boolean isSynthetic() { + return (SYNTHETIC & getModifiers()) != 0; + } + + public boolean isVarArgs() { + return (VARARGS & getModifiers()) != 0; + } + public boolean isDefault() { if (isConstructor()) { return false; @@ -696,27 +709,6 @@ return UNSAFE.getByte(metaspaceMethod + config.methodIntrinsicIdOffset) & 0xff; } - @Override - public JavaConstant invoke(JavaConstant receiver, JavaConstant[] arguments) { - assert !isConstructor(); - Method javaMethod = (Method) toJava(); - javaMethod.setAccessible(true); - - Object[] objArguments = new Object[arguments.length]; - for (int i = 0; i < arguments.length; i++) { - objArguments[i] = HotSpotObjectConstantImpl.asBoxedValue(arguments[i]); - } - Object objReceiver = receiver != null && !receiver.isNull() ? ((HotSpotObjectConstantImpl) receiver).object() : null; - - try { - Object objResult = javaMethod.invoke(objReceiver, objArguments); - return javaMethod.getReturnType() == void.class ? null : HotSpotObjectConstantImpl.forBoxedValue(getSignature().getReturnKind(), objResult); - - } catch (IllegalAccessException | InvocationTargetException ex) { - throw new IllegalArgumentException(ex); - } - } - /** * Allocates a compile id for this method by asking the VM for one. *
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java Wed Sep 07 15:17:13 2016 +0200 @@ -25,6 +25,7 @@ import static java.util.Objects.requireNonNull; import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM; import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime; +import static jdk.vm.ci.hotspot.HotSpotModifiers.jvmClassModifiers; import static jdk.vm.ci.hotspot.HotSpotVMConfig.config; import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE; @@ -48,7 +49,6 @@ import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.JavaType; -import jdk.vm.ci.meta.ModifiersProvider; import jdk.vm.ci.meta.ResolvedJavaField; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -151,7 +151,7 @@ if (isArray()) { return (getElementalType().getModifiers() & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED)) | Modifier.FINAL | Modifier.ABSTRACT; } else { - return getAccessFlags() & ModifiersProvider.jvmClassModifiers(); + return getAccessFlags() & jvmClassModifiers(); } } @@ -506,7 +506,7 @@ synchronized HotSpotResolvedJavaField createField(String fieldName, JavaType type, long offset, int rawFlags) { HotSpotResolvedJavaField result = null; - final int flags = rawFlags & ModifiersProvider.jvmFieldModifiers(); + final int flags = rawFlags & HotSpotModifiers.jvmFieldModifiers(); final long id = offset + ((long) flags << 32);
--- a/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotVMConfig.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotVMConfig.java Wed Sep 07 15:17:13 2016 +0200 @@ -106,6 +106,13 @@ final int jvmAccFieldHasGenericSignature = getConstant("JVM_ACC_FIELD_HAS_GENERIC_SIGNATURE", Integer.class); final int jvmAccIsCloneable = getConstant("JVM_ACC_IS_CLONEABLE", Integer.class); + // These modifiers are not public in Modifier so we get them via vmStructs. + final int jvmAccSynthetic = getConstant("JVM_ACC_SYNTHETIC", Integer.class); + final int jvmAccAnnotation = getConstant("JVM_ACC_ANNOTATION", Integer.class); + final int jvmAccBridge = getConstant("JVM_ACC_BRIDGE", Integer.class); + final int jvmAccVarargs = getConstant("JVM_ACC_VARARGS", Integer.class); + final int jvmAccEnum = getConstant("JVM_ACC_ENUM", Integer.class); + final int runtimeCallStackSize = getConstant("frame::arg_reg_save_area_bytes", Integer.class, amd64RequiredInt); final int markWordNoHashInPlace = getConstant("markOopDesc::no_hash_in_place", Integer.class); final int markWordNoLockInPlace = getConstant("markOopDesc::no_lock_in_place", Integer.class);
--- a/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/MetaUtil.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/MetaUtil.java Wed Sep 07 15:17:13 2016 +0200 @@ -22,9 +22,6 @@ */ package jdk.vm.ci.meta; -import java.lang.reflect.Field; -import java.lang.reflect.Modifier; - /** * Miscellaneous collection of utility methods used by {@code jdk.vm.ci.meta} and its clients. */ @@ -226,17 +223,4 @@ } return obj.getClass().getName() + "@" + System.identityHashCode(obj); } - - /** - * Used to lookup constants from {@link Modifier} that are not public (VARARGS, SYNTHETIC etc.). - */ - static int getNonPublicModifierStaticField(String name) { - try { - Field field = Modifier.class.getDeclaredField(name); - field.setAccessible(true); - return field.getInt(null); - } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { - throw new InternalError(e); - } - } }
--- a/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ModifiersProvider.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ModifiersProvider.java Wed Sep 07 15:17:13 2016 +0200 @@ -22,18 +22,9 @@ */ package jdk.vm.ci.meta; -import static java.lang.reflect.Modifier.ABSTRACT; -import static java.lang.reflect.Modifier.FINAL; -import static java.lang.reflect.Modifier.INTERFACE; -import static java.lang.reflect.Modifier.NATIVE; import static java.lang.reflect.Modifier.PRIVATE; import static java.lang.reflect.Modifier.PROTECTED; import static java.lang.reflect.Modifier.PUBLIC; -import static java.lang.reflect.Modifier.STATIC; -import static java.lang.reflect.Modifier.STRICT; -import static java.lang.reflect.Modifier.SYNCHRONIZED; -import static java.lang.reflect.Modifier.TRANSIENT; -import static java.lang.reflect.Modifier.VOLATILE; import java.lang.reflect.Modifier; @@ -42,17 +33,9 @@ * language {@linkplain #getModifiers() modifiers}. */ public interface ModifiersProvider { - int BRIDGE = MetaUtil.getNonPublicModifierStaticField("BRIDGE"); - int VARARGS = MetaUtil.getNonPublicModifierStaticField("VARARGS"); - int SYNTHETIC = MetaUtil.getNonPublicModifierStaticField("SYNTHETIC"); - int ANNOTATION = MetaUtil.getNonPublicModifierStaticField("ANNOTATION"); - int ENUM = MetaUtil.getNonPublicModifierStaticField("ENUM"); - int MANDATED = MetaUtil.getNonPublicModifierStaticField("MANDATED"); /** - * Returns the Java Virtual Machine modifiers for this element. Note that this can differ from - * standard Java Reflection modifiers. For example at the JVM level, classes ( - * {@link ResolvedJavaType}) can not be private or protected. + * Returns the modifiers for this element. */ int getModifiers(); @@ -161,17 +144,4 @@ default boolean isConcrete() { return !isAbstract(); } - - static int jvmClassModifiers() { - // no SUPER - return PUBLIC | FINAL | INTERFACE | ABSTRACT | ANNOTATION | ENUM | SYNTHETIC; - } - - static int jvmMethodModifiers() { - return PUBLIC | PRIVATE | PROTECTED | STATIC | FINAL | SYNCHRONIZED | BRIDGE | VARARGS | NATIVE | ABSTRACT | STRICT | SYNTHETIC; - } - - static int jvmFieldModifiers() { - return PUBLIC | PRIVATE | PROTECTED | STATIC | FINAL | VOLATILE | TRANSIENT | ENUM | SYNTHETIC; - } }
--- a/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ResolvedJavaMethod.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ResolvedJavaMethod.java Wed Sep 07 15:17:13 2016 +0200 @@ -26,7 +26,6 @@ import java.lang.reflect.AnnotatedElement; import java.lang.reflect.Array; import java.lang.reflect.Method; -import java.lang.reflect.Modifier; import java.lang.reflect.Type; /** @@ -72,14 +71,6 @@ */ int getMaxStackSize(); - /** - * {@inheritDoc} - * <p> - * Only the {@linkplain Modifier#methodModifiers() method flags} specified in the JVM - * specification will be included in the returned mask. - */ - int getModifiers(); - default boolean isFinal() { return ModifiersProvider.super.isFinalFlagSet(); } @@ -88,9 +79,7 @@ * Determines if this method is a synthetic method as defined by the Java Language * Specification. */ - default boolean isSynthetic() { - return (SYNTHETIC & getModifiers()) == SYNTHETIC; - } + boolean isSynthetic(); /** * Checks that the method is a @@ -99,9 +88,7 @@ * * @return whether the method is a varargs method */ - default boolean isVarArgs() { - return (VARARGS & getModifiers()) == VARARGS; - } + boolean isVarArgs(); /** * Checks that the method is a @@ -110,9 +97,7 @@ * * @return whether the method is a bridge method */ - default boolean isBridge() { - return (BRIDGE & getModifiers()) == BRIDGE; - } + boolean isBridge(); /** * Returns {@code true} if this method is a default method; returns {@code false} otherwise. @@ -228,18 +213,6 @@ LocalVariableTable getLocalVariableTable(); /** - * Invokes the underlying method represented by this object, on the specified object with the - * specified parameters. This method is similar to a reflective method invocation by - * {@link Method#invoke}. - * - * @param receiver The receiver for the invocation, or {@code null} if it is a static method. - * @param arguments The arguments for the invocation. - * @return The value returned by the method invocation, or {@code null} if the return type is - * {@code void}. - */ - JavaConstant invoke(JavaConstant receiver, JavaConstant[] arguments); - - /** * Gets the encoding of (that is, a constant representing the value of) this method. * * @return a constant representing a reference to this method
--- a/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ResolvedJavaType.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ResolvedJavaType.java Wed Sep 07 15:17:13 2016 +0200 @@ -68,15 +68,6 @@ */ boolean isPrimitive(); - /** - * {@inheritDoc} - * <p> - * Only the flags specified in the JVM specification will be included in the returned mask. This - * method is identical to {@link Class#getModifiers()} in terms of the value return for this - * type. - */ - int getModifiers(); - /* * The setting of the final bit for types is a bit confusing since arrays are marked as final. * This method provides a semantically equivalent test that appropriate for types.
--- a/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaMethod.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaMethod.java Wed Sep 07 15:17:13 2016 +0200 @@ -418,7 +418,6 @@ // @formatter:off private static final String[] untestedApiMethods = { - "invoke", "newInstance", "getDeclaringClass", "getEncoding",
--- a/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaType.java Wed Sep 07 11:22:05 2016 +0200 +++ b/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaType.java Wed Sep 07 15:17:13 2016 +0200 @@ -59,7 +59,6 @@ import jdk.vm.ci.meta.Assumptions.AssumptionResult; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.ModifiersProvider; import jdk.vm.ci.meta.ResolvedJavaField; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -123,8 +122,9 @@ public void getModifiersTest() { for (Class<?> c : classes) { ResolvedJavaType type = metaAccess.lookupJavaType(c); - int expected = c.getModifiers() & ModifiersProvider.jvmClassModifiers(); - int actual = type.getModifiers() & ModifiersProvider.jvmClassModifiers(); + int mask = Modifier.classModifiers() & ~Modifier.STATIC; + int expected = c.getModifiers() & mask; + int actual = type.getModifiers() & mask; Class<?> elementalType = c; while (elementalType.isArray()) { elementalType = elementalType.getComponentType();
--- a/src/share/vm/jvmci/jvmciCompilerToVM.cpp Wed Sep 07 11:22:05 2016 +0200 +++ b/src/share/vm/jvmci/jvmciCompilerToVM.cpp Wed Sep 07 15:17:13 2016 +0200 @@ -464,9 +464,20 @@ return (jlong) (address) method->exception_table_start(); C2V_END -C2V_VMENTRY(jobject, getResolvedJavaMethodAtSlot, (JNIEnv *, jobject, jclass holder_handle, jint slot)) - oop java_class = JNIHandles::resolve(holder_handle); - Klass* holder = java_lang_Class::as_Klass(java_class); +C2V_VMENTRY(jobject, asResolvedJavaMethod, (JNIEnv *, jobject, jobject executable_handle)) + oop executable = JNIHandles::resolve(executable_handle); + oop mirror = NULL; + int slot = 0; + + if (executable->klass() == SystemDictionary::reflect_Constructor_klass()) { + mirror = java_lang_reflect_Constructor::clazz(executable); + slot = java_lang_reflect_Constructor::slot(executable); + } else { + assert(executable->klass() == SystemDictionary::reflect_Method_klass(), "wrong type"); + mirror = java_lang_reflect_Method::clazz(executable); + slot = java_lang_reflect_Method::slot(executable); + } + Klass* holder = java_lang_Class::as_Klass(mirror); methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot); oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL); return JNIHandles::make_local(THREAD, result); @@ -1463,6 +1474,17 @@ return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord; C2V_END +C2V_VMENTRY(void, compileToBytecode, (JNIEnv*, jobject, jobject lambda_form_handle)) + Handle lambda_form = JNIHandles::resolve_non_null(lambda_form_handle); + if (lambda_form->is_a(SystemDictionary::LambdaForm_klass())) { + TempNewSymbol compileToBytecode = SymbolTable::new_symbol("compileToBytecode", CHECK); + JavaValue result(T_VOID); + JavaCalls::call_special(&result, lambda_form, SystemDictionary::LambdaForm_klass(), compileToBytecode, vmSymbols::void_method_signature(), CHECK); + } else { + THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), + err_msg("Unexpected type: %s", lambda_form->klass()->external_name())); + } +C2V_END #define CC (char*) /*cast a literal from (const char*)*/ #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &(c2v_ ## f)) @@ -1470,6 +1492,7 @@ #define STRING "Ljava/lang/String;" #define OBJECT "Ljava/lang/Object;" #define CLASS "Ljava/lang/Class;" +#define EXECUTABLE "Ljava/lang/reflect/Executable;" #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;" #define INSTALLED_CODE "Ljdk/vm/ci/code/InstalledCode;" #define TARGET_DESCRIPTION "Ljdk/vm/ci/code/TargetDescription;" @@ -1515,7 +1538,7 @@ {CC"getClassInitializer", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(getClassInitializer)}, {CC"hasFinalizableSubclass", CC"("HS_RESOLVED_KLASS")Z", FN_PTR(hasFinalizableSubclass)}, {CC"getMaxCallTargetOffset", CC"(J)J", FN_PTR(getMaxCallTargetOffset)}, - {CC"getResolvedJavaMethodAtSlot", CC"("CLASS"I)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethodAtSlot)}, + {CC"asResolvedJavaMethod", CC "(" EXECUTABLE ")" HS_RESOLVED_METHOD, FN_PTR(asResolvedJavaMethod)}, {CC"getResolvedJavaMethod", CC"(Ljava/lang/Object;J)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethod)}, {CC"getConstantPool", CC"(Ljava/lang/Object;)"HS_CONSTANT_POOL, FN_PTR(getConstantPool)}, {CC"getResolvedJavaType", CC"(Ljava/lang/Object;JZ)"HS_RESOLVED_KLASS, FN_PTR(getResolvedJavaType)}, @@ -1542,6 +1565,7 @@ {CC"flushDebugOutput", CC"()V", FN_PTR(flushDebugOutput)}, {CC"methodDataProfileDataSize", CC"(JI)I", FN_PTR(methodDataProfileDataSize)}, {CC"interpreterFrameSize", CC"("BYTECODE_FRAME")I", FN_PTR(interpreterFrameSize)}, + {CC"compileToBytecode", CC "(" OBJECT ")V", FN_PTR(compileToBytecode)}, }; int CompilerToVM::methods_count() {
--- a/src/share/vm/jvmci/vmStructs_jvmci.hpp Wed Sep 07 11:22:05 2016 +0200 +++ b/src/share/vm/jvmci/vmStructs_jvmci.hpp Wed Sep 07 15:17:13 2016 +0200 @@ -108,8 +108,11 @@ declare_constant(JVMCIRuntime::by_holder) \ declare_constant(JVMCIRuntime::by_full_signature) \ \ + declare_preprocessor_constant("JVM_ACC_VARARGS", JVM_ACC_VARARGS) \ + declare_preprocessor_constant("JVM_ACC_BRIDGE", JVM_ACC_BRIDGE) \ + declare_preprocessor_constant("JVM_ACC_ANNOTATION", JVM_ACC_ANNOTATION) \ + declare_preprocessor_constant("JVM_ACC_ENUM", JVM_ACC_ENUM) \ declare_preprocessor_constant("JVM_ACC_SYNTHETIC", JVM_ACC_SYNTHETIC) \ - declare_preprocessor_constant("JVM_RECOGNIZED_FIELD_MODIFIERS", JVM_RECOGNIZED_FIELD_MODIFIERS) \ \ declare_constant(BitData::exception_seen_flag) \ declare_constant(BitData::null_seen_flag) \