Skip to content

[GR-71185] Migrate JNIRegistrationUtil to JVMCI reflection #12663

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
graalvmbot merged 3 commits into from
Dec 5, 2025
Merged

[GR-71185] Migrate JNIRegistrationUtil to JVMCI reflection #12663

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
5645939
svm: introduce InternalFeatureAccess
zapster Dec 2, 2025
baaa45c
svm: introduce JVMCIRuntimeClassInitializationSupport
zapster Dec 2, 2025
3e7a3c8
svm: implement core reflection based JNIRegistrationUtil with JVCMI m…
zapster Dec 2, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 9 additions & 0 deletions substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/feature/InternalFeature.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,6 +40,8 @@
import jdk.graal.compiler.options.OptionValues;
import jdk.graal.compiler.phases.tiers.Suites;
import jdk.graal.compiler.phases.util.Providers;
import jdk.vm.ci.meta.MetaAccessProvider;
import jdk.vm.ci.meta.ResolvedJavaType;

public interface InternalFeature extends Feature {

Expand Down Expand Up @@ -135,4 +137,11 @@ interface AfterAbstractImageCreationAccess extends FeatureAccess {
*/
default void afterAbstractImageCreation(AfterAbstractImageCreationAccess access) {
}

@Platforms(Platform.HOSTED_ONLY.class)
interface InternalFeatureAccess extends FeatureAccess {
ResolvedJavaType findTypeByName(String className);

MetaAccessProvider getMetaAccess();
}
}
68 changes: 36 additions & 32 deletions substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/JNIRegistrationUtil.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,27 +24,28 @@
*/
package com.oracle.svm.core.jdk;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;

import org.graalvm.nativeimage.ImageSingletons;
import org.graalvm.nativeimage.Platform;
import org.graalvm.nativeimage.hosted.Feature.AfterAnalysisAccess;
import org.graalvm.nativeimage.hosted.Feature.DuringAnalysisAccess;
import org.graalvm.nativeimage.hosted.Feature.FeatureAccess;
import org.graalvm.nativeimage.hosted.RuntimeJNIAccess;
import org.graalvm.nativeimage.hosted.RuntimeReflection;
import org.graalvm.nativeimage.impl.InternalPlatform;
import org.graalvm.nativeimage.impl.RuntimeClassInitializationSupport;

import com.oracle.svm.core.feature.InternalFeature.InternalFeatureAccess;
import com.oracle.svm.core.util.ConcurrentIdentityHashMap;
import com.oracle.svm.core.util.VMError;
import com.oracle.svm.util.ReflectionUtil;
import com.oracle.svm.util.JVMCIReflectionUtil;
import com.oracle.svm.util.JVMCIRuntimeClassInitializationSupport;
import com.oracle.svm.util.dynamicaccess.JVMCIRuntimeJNIAccess;
import com.oracle.svm.util.dynamicaccess.JVMCIRuntimeReflection;

import jdk.vm.ci.meta.ResolvedJavaField;
import jdk.vm.ci.meta.ResolvedJavaMethod;
import jdk.vm.ci.meta.ResolvedJavaType;

/**
* Utility methods used by features that perform JNI registration.
Expand Down Expand Up @@ -72,52 +73,55 @@ protected static boolean isWindows() {
}

protected static void initializeAtRunTime(FeatureAccess access, String... classNames) {
RuntimeClassInitializationSupport classInitSupport = ImageSingletons.lookup(RuntimeClassInitializationSupport.class);
InternalFeatureAccess internalAccess = (InternalFeatureAccess) access;
JVMCIRuntimeClassInitializationSupport classInitSupport = JVMCIRuntimeClassInitializationSupport.singleton();
for (String className : classNames) {
classInitSupport.initializeAtRunTime(clazz(access, className), "for JDK native code support via JNI");
classInitSupport.initializeAtRunTime(type(internalAccess, className), "for JDK native code support via JNI");
}
}

protected static Class<?> clazz(FeatureAccess access, String className) {
Class<?> classByName = access.findClassByName(className);
VMError.guarantee(classByName != null, "class %s not found", className);
return classByName;
protected static ResolvedJavaType type(FeatureAccess access, String className) {
ResolvedJavaType typeByName = ((InternalFeatureAccess) access).findTypeByName(className);
VMError.guarantee(typeByName != null, "class %s not found", className);
return typeByName;
}

protected static Optional<Class<?>> optionalClazz(FeatureAccess access, String className) {
Class<?> classByName = access.findClassByName(className);
return Optional.ofNullable(classByName);
protected static Optional<? extends ResolvedJavaType> optionalType(FeatureAccess access, String className) {
ResolvedJavaType typeByName = ((InternalFeatureAccess) access).findTypeByName(className);
return Optional.ofNullable(typeByName);
}

protected static Optional<Method> optionalMethod(FeatureAccess access, String className, String methodName, Class<?>... parameterTypes) {
return optionalClazz(access, className)
.flatMap(clazz -> Optional.ofNullable(ReflectionUtil.lookupMethod(true, clazz, methodName, parameterTypes)));
protected static Optional<ResolvedJavaMethod> optionalMethod(FeatureAccess access, String className, String methodName, Class<?>... parameterTypes) {
InternalFeatureAccess internalAccess = (InternalFeatureAccess) access;
return optionalType(access, className)
.flatMap(clazz -> Optional.ofNullable(JVMCIReflectionUtil.getUniqueDeclaredMethod(true, internalAccess.getMetaAccess(), clazz, methodName, parameterTypes)));
}

protected static Method method(FeatureAccess access, String className, String methodName, Class<?>... parameterTypes) {
return ReflectionUtil.lookupMethod(clazz(access, className), methodName, parameterTypes);
protected static ResolvedJavaMethod method(FeatureAccess access, String className, String methodName, Class<?>... parameterTypes) {
return JVMCIReflectionUtil.getUniqueDeclaredMethod(((InternalFeatureAccess) access).getMetaAccess(), type(access, className), methodName, parameterTypes);
}

protected static Constructor<?> constructor(FeatureAccess access, String className, Class<?>... parameterTypes) {
return ReflectionUtil.lookupConstructor(clazz(access, className), parameterTypes);
protected static ResolvedJavaMethod constructor(FeatureAccess access, String className, Class<?>... parameterTypes) {
return JVMCIReflectionUtil.getDeclaredConstructor(((InternalFeatureAccess) access).getMetaAccess(), type(access, className), parameterTypes);
}

protected static Field[] fields(FeatureAccess access, String className, String... fieldNames) {
Class<?> clazz = clazz(access, className);
Field[] result = new Field[fieldNames.length];
protected static ResolvedJavaField[] fields(FeatureAccess access, String className, String... fieldNames) {
ResolvedJavaType type = type(access, className);
ResolvedJavaField[] result = new ResolvedJavaField[fieldNames.length];
for (int i = 0; i < fieldNames.length; i++) {
result[i] = ReflectionUtil.lookupField(clazz, fieldNames[i]);
result[i] = JVMCIReflectionUtil.getUniqueDeclaredField(type, fieldNames[i]);
}
return result;
}

protected static void registerForThrowNew(FeatureAccess access, String... exceptionClassNames) {
InternalFeatureAccess internalAccess = (InternalFeatureAccess) access;
for (String exceptionClassName : exceptionClassNames) {
RuntimeJNIAccess.register(clazz(access, exceptionClassName));
RuntimeJNIAccess.register(constructor(access, exceptionClassName, String.class));
JVMCIRuntimeJNIAccess.register(type(internalAccess, exceptionClassName));
JVMCIRuntimeJNIAccess.register(constructor(internalAccess, exceptionClassName, String.class));

RuntimeReflection.register(clazz(access, exceptionClassName));
RuntimeReflection.register(constructor(access, exceptionClassName, String.class));
JVMCIRuntimeReflection.register(type(internalAccess, exceptionClassName));
JVMCIRuntimeReflection.register(constructor(internalAccess, exceptionClassName, String.class));
}
}

Expand Down
5 changes: 3 additions & 2 deletions substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FeatureHandler.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -64,6 +64,7 @@

import jdk.graal.compiler.debug.DebugContext;
import jdk.graal.compiler.options.Option;
import jdk.vm.ci.meta.MetaAccessProvider;

/**
* Handles the registration and iterations of {@link Feature features}.
Expand Down Expand Up @@ -115,8 +116,8 @@ public boolean containsFeature(Class<?> c) {
}

@SuppressWarnings("unchecked")
public void registerFeatures(ImageClassLoader loader, DebugContext debug) {
IsInConfigurationAccessImpl access = new IsInConfigurationAccessImpl(this, loader, debug);
public void registerFeatures(ImageClassLoader loader, MetaAccessProvider originalMetaAccess, DebugContext debug) {
IsInConfigurationAccessImpl access = new IsInConfigurationAccessImpl(this, loader, originalMetaAccess, debug);

LinkedHashSet<Class<?>> automaticFeatures = new LinkedHashSet<>();
NativeImageSystemClassLoader nativeImageSystemClassLoader = NativeImageSystemClassLoader.singleton();
Expand Down
96 changes: 84 additions & 12 deletions substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FeatureImpl.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -98,6 +98,7 @@
import com.oracle.svm.hosted.meta.HostedField;
import com.oracle.svm.hosted.meta.HostedMetaAccess;
import com.oracle.svm.hosted.meta.HostedMethod;
import com.oracle.svm.hosted.meta.HostedType;
import com.oracle.svm.hosted.meta.HostedUniverse;
import com.oracle.svm.hosted.option.HostedOptionProvider;
import com.oracle.svm.util.AnnotationUtil;
Expand All @@ -108,11 +109,12 @@
import jdk.graal.compiler.phases.util.Providers;
import jdk.internal.vm.annotation.Stable;
import jdk.vm.ci.meta.MetaAccessProvider;
import jdk.vm.ci.meta.ResolvedJavaType;

@SuppressWarnings("deprecation")
public class FeatureImpl {

public abstract static class FeatureAccessImpl implements Feature.FeatureAccess {
public abstract static class FeatureAccessImpl implements InternalFeature.InternalFeatureAccess {

protected final FeatureHandler featureHandler;
protected final ImageClassLoader imageClassLoader;
Expand Down Expand Up @@ -174,8 +176,25 @@ public ClassLoader getApplicationClassLoader() {
}

public static class IsInConfigurationAccessImpl extends FeatureAccessImpl implements Feature.IsInConfigurationAccess {
IsInConfigurationAccessImpl(FeatureHandler featureHandler, ImageClassLoader imageClassLoader, DebugContext debugContext) {
private final MetaAccessProvider metaAccess;

IsInConfigurationAccessImpl(FeatureHandler featureHandler, ImageClassLoader imageClassLoader, MetaAccessProvider metaAccess, DebugContext debugContext) {
super(featureHandler, imageClassLoader, debugContext);
this.metaAccess = metaAccess;
}

@Override
public ResolvedJavaType findTypeByName(String className) {
Class<?> clazz = findClassByName(className);
if (clazz == null) {
return null;
}
return getMetaAccess().lookupJavaType(clazz);
}

@Override
public MetaAccessProvider getMetaAccess() {
return metaAccess;
}
}

Expand All @@ -190,6 +209,7 @@ public AfterRegistrationAccessImpl(FeatureHandler featureHandler, ImageClassLoad
this.mainEntryPoint = mainEntryPoint;
}

@Override
public MetaAccessProvider getMetaAccess() {
return metaAccess;
}
Expand Down Expand Up @@ -221,6 +241,15 @@ public JNIAccess getJNIAccess() {
public ForeignAccess getForeignAccess() {
return ForeignAccessImpl.singleton();
}

@Override
public ResolvedJavaType findTypeByName(String className) {
Class<?> clazz = findClassByName(className);
if (clazz == null) {
return null;
}
return getMetaAccess().lookupJavaType(clazz);
}
}

abstract static class AnalysisAccessBase extends FeatureAccessImpl {
Expand All @@ -240,10 +269,12 @@ public AnalysisUniverse getUniverse() {
return bb.getUniverse();
}

@Override
public AnalysisMetaAccess getMetaAccess() {
return bb.getMetaAccess();
}

@Override
public AnalysisType findTypeByName(String className) {
Class<?> clazz = findClassByName(className);
if (clazz == null) {
Expand Down Expand Up @@ -692,20 +723,45 @@ public OnAnalysisExitAccessImpl(FeatureHandler featureHandler, ImageClassLoader
}
}

public static class BeforeUniverseBuildingAccessImpl extends FeatureAccessImpl implements Feature.BeforeUniverseBuildingAccess {
public abstract static class HostedFeatureAccessImpl extends FeatureAccessImpl {

HostedFeatureAccessImpl(FeatureHandler featureHandler, ImageClassLoader imageClassLoader, DebugContext debugContext) {
super(featureHandler, imageClassLoader, debugContext);
}

@Override
public abstract HostedMetaAccess getMetaAccess();

@Override
public HostedType findTypeByName(String className) {
Class<?> clazz = findClassByName(className);
if (clazz == null) {
return null;
}
try {
return getMetaAccess().lookupJavaType(clazz);
} catch (AnalysisError.TypeNotFoundError e) {
// Type not found during analysis
return null;
}
}
}

public static class BeforeUniverseBuildingAccessImpl extends HostedFeatureAccessImpl implements Feature.BeforeUniverseBuildingAccess {
protected final HostedMetaAccess hMetaAccess;

BeforeUniverseBuildingAccessImpl(FeatureHandler featureHandler, ImageClassLoader imageClassLoader, DebugContext debugContext, HostedMetaAccess hMetaAccess) {
super(featureHandler, imageClassLoader, debugContext);
this.hMetaAccess = hMetaAccess;
}

@Override
public HostedMetaAccess getMetaAccess() {
return hMetaAccess;
}
}

public static class CompilationAccessImpl extends FeatureAccessImpl implements Feature.CompilationAccess {
public static class CompilationAccessImpl extends HostedFeatureAccessImpl implements Feature.CompilationAccess {

protected final AnalysisUniverse aUniverse;
protected final HostedUniverse hUniverse;
Expand Down Expand Up @@ -748,6 +804,7 @@ public void registerAsImmutable(Object root, Predicate<Object> includeObject) {
heap.registerAsImmutable(root, includeObject);
}

@Override
public HostedMetaAccess getMetaAccess() {
return (HostedMetaAccess) getProviders().getMetaAccess();
}
Expand Down Expand Up @@ -825,7 +882,7 @@ public BeforeHeapLayoutAccessImpl(FeatureHandler featureHandler, ImageClassLoade
}
}

public static class AfterHeapLayoutAccessImpl extends FeatureAccessImpl implements Feature.AfterHeapLayoutAccess {
public static class AfterHeapLayoutAccessImpl extends HostedFeatureAccessImpl implements Feature.AfterHeapLayoutAccess {
protected final HostedMetaAccess hMetaAccess;
protected final NativeImageHeap heap;

Expand All @@ -835,6 +892,7 @@ public AfterHeapLayoutAccessImpl(FeatureHandler featureHandler, ImageClassLoader
this.hMetaAccess = hMetaAccess;
}

@Override
public HostedMetaAccess getMetaAccess() {
return hMetaAccess;
}
Expand All @@ -844,7 +902,7 @@ public NativeImageHeap getHeap() {
}
}

public static class BeforeImageWriteAccessImpl extends FeatureAccessImpl implements Feature.BeforeImageWriteAccess {
public static class BeforeImageWriteAccessImpl extends HostedFeatureAccessImpl implements Feature.BeforeImageWriteAccess {
private List<Function<LinkerInvocation, LinkerInvocation>> linkerInvocationTransformers = null;

protected final String imageName;
Expand Down Expand Up @@ -887,7 +945,8 @@ public HostedUniverse getHostedUniverse() {
return hUniverse;
}

public HostedMetaAccess getHostedMetaAccess() {
@Override
public HostedMetaAccess getMetaAccess() {
return hMetaAccess;
}

Expand All @@ -906,15 +965,17 @@ public void registerLinkerInvocationTransformer(Function<LinkerInvocation, Linke
}
}

public static class AfterAbstractImageCreationAccessImpl extends FeatureAccessImpl implements InternalFeature.AfterAbstractImageCreationAccess {
public static class AfterAbstractImageCreationAccessImpl extends HostedFeatureAccessImpl implements InternalFeature.AfterAbstractImageCreationAccess {
protected final AbstractImage abstractImage;
protected final SubstrateBackend substrateBackend;
private final HostedMetaAccess hMetaAccess;

AfterAbstractImageCreationAccessImpl(FeatureHandler featureHandler, ImageClassLoader imageClassLoader, DebugContext debugContext, AbstractImage abstractImage,
AfterAbstractImageCreationAccessImpl(FeatureHandler featureHandler, ImageClassLoader imageClassLoader, HostedMetaAccess hMetaAccess, DebugContext debugContext, AbstractImage abstractImage,
SubstrateBackend substrateBackend) {
super(featureHandler, imageClassLoader, debugContext);
this.abstractImage = abstractImage;
this.substrateBackend = substrateBackend;
this.hMetaAccess = hMetaAccess;
}

public AbstractImage getImage() {
Expand All @@ -924,22 +985,28 @@ public AbstractImage getImage() {
public SubstrateBackend getSubstrateBackend() {
return substrateBackend;
}

@Override
public HostedMetaAccess getMetaAccess() {
return hMetaAccess;
}
}

public static class AfterImageWriteAccessImpl extends FeatureAccessImpl implements Feature.AfterImageWriteAccess {
public static class AfterImageWriteAccessImpl extends HostedFeatureAccessImpl implements Feature.AfterImageWriteAccess {
private final HostedUniverse hUniverse;
protected final LinkerInvocation linkerInvocation;
protected final Path tempDirectory;
protected final NativeImageKind imageKind;
private final HostedMetaAccess hMetaAcces;

AfterImageWriteAccessImpl(FeatureHandler featureHandler, ImageClassLoader imageClassLoader, HostedUniverse hUniverse, LinkerInvocation linkerInvocation, Path tempDirectory,
NativeImageKind imageKind,
DebugContext debugContext) {
NativeImageKind imageKind, HostedMetaAccess hMetaAcces, DebugContext debugContext) {
super(featureHandler, imageClassLoader, debugContext);
this.hUniverse = hUniverse;
this.linkerInvocation = linkerInvocation;
this.tempDirectory = tempDirectory;
this.imageKind = imageKind;
this.hMetaAcces = hMetaAcces;
}

public HostedUniverse getUniverse() {
Expand All @@ -966,5 +1033,10 @@ public NativeImageKind getImageKind() {
public List<String> getImageSymbols(boolean onlyGlobal) {
return linkerInvocation.getImageSymbols(onlyGlobal);
}

@Override
public HostedMetaAccess getMetaAccess() {
return hMetaAcces;
}
}
}
Loading
Loading