From 120d2dc82aa2d9e3d57eb8a863461381cea0502a Mon Sep 17 00:00:00 2001 From: Christian Wimmer Date: Mon, 22 Jan 2024 14:09:17 -0800 Subject: [PATCH] Remove unncessary SnippetReflectionProvider arguments and fields --- .../hotspot/amd64/test/StubAVXTest.java | 16 +- .../replacements/test/ReplacementsTest.java | 8 +- .../replacements/test/SnippetsTest.java | 2 +- .../compiler/hotspot/EncodedSnippets.java | 6 +- .../hotspot/HotSpotBackendFactory.java | 6 +- .../hotspot/HotSpotReplacementsImpl.java | 13 +- .../hotspot/SymbolicSnippetEncoder.java | 27 ++- .../replacements/ReplacementsImpl.java | 8 +- .../compiler/truffle/TruffleCompilerImpl.java | 2 +- .../phases/InstrumentBranchesPhase.java | 8 +- .../truffle/phases/InstrumentPhase.java | 8 +- .../InstrumentTruffleBoundariesPhase.java | 10 +- .../truffle/phases/InstrumentationSuite.java | 8 +- .../amd64/AMD64CalleeSavedRegisters.java | 4 +- .../oracle/svm/core/StaticFieldsSupport.java | 25 ++- .../RuntimeCPUFeatureCheckImpl.java | 10 +- .../svm/core/feature/InternalFeature.java | 18 +- .../core/graal/jdk/JDKIntrinsicsFeature.java | 17 +- .../core/graal/meta/RuntimeConfiguration.java | 10 +- .../graal/meta/SubstrateReplacements.java | 7 +- .../graal/replacements/SubstrateGraphKit.java | 4 +- .../snippets/StackOverflowCheckFeature.java | 17 +- .../graal/stackvalue/StackValueFeature.java | 15 +- .../svm/graal/RuntimeCPUFeatureRegion.java | 46 +++--- .../svm/graal/SubstrateGraalRuntime.java | 12 +- .../RuntimeCompilationFeature.java | 7 +- .../graal/isolated/IsolatedGraalUtils.java | 26 +-- .../SubstrateRuntimeConfigurationBuilder.java | 4 +- .../svm/hosted/HostedConfiguration.java | 7 +- .../svm/hosted/NativeImageGenerator.java | 24 ++- .../oracle/svm/hosted/ResourcesFeature.java | 11 +- .../svm/hosted/c/CGlobalDataFeature.java | 43 +++-- .../hosted/c/function/CEntryPointSupport.java | 3 +- .../hosted/cenum/CEnumCallWrapperMethod.java | 2 +- .../EarlyClassInitializerAnalysis.java | 36 ++-- .../svm/hosted/code/CCallStubMethod.java | 4 +- .../code/CEntryPointCallStubMethod.java | 4 +- .../oracle/svm/hosted/code/CompileQueue.java | 10 +- .../svm/hosted/code/HostedReplacements.java | 5 +- .../HostedRuntimeConfigurationBuilder.java | 4 +- .../SharedRuntimeConfigurationBuilder.java | 6 +- .../svm/hosted/phases/CInterfaceEnumTool.java | 9 +- .../phases/CInterfaceInvocationPlugin.java | 23 ++- .../svm/hosted/phases/EnumSwitchPlugin.java | 9 +- .../SubstrateClassInitializationPlugin.java | 11 +- .../svm/hosted/reflect/ReflectionFeature.java | 5 +- .../hosted/snippets/ReflectionPlugins.java | 17 +- .../SubstrateGraphBuilderPlugins.java | 156 +++++++++--------- .../AutomaticUnsafeTransformationSupport.java | 11 +- .../hosted/thread/VMThreadLocalCollector.java | 15 +- .../svm/hosted/thread/VMThreadMTFeature.java | 41 +++-- .../svm/truffle/TruffleBaseFeature.java | 6 +- .../oracle/svm/truffle/TruffleFeature.java | 6 +- .../oracle/svm/truffle/TruffleSupport.java | 5 +- .../api/SubstrateTruffleCompilerImpl.java | 26 +-- 55 files changed, 380 insertions(+), 463 deletions(-) diff --git a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/amd64/test/StubAVXTest.java b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/amd64/test/StubAVXTest.java index 7476fb78df07..5662e05d71f9 100644 --- a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/amd64/test/StubAVXTest.java +++ b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/hotspot/amd64/test/StubAVXTest.java @@ -31,17 +31,19 @@ import java.util.BitSet; +import org.junit.Assume; +import org.junit.Before; +import org.junit.Test; + import jdk.graal.compiler.api.replacements.Snippet; import jdk.graal.compiler.asm.amd64.AMD64Address; import jdk.graal.compiler.asm.amd64.AMD64MacroAssembler; import jdk.graal.compiler.bytecode.BytecodeProvider; -import jdk.graal.compiler.core.test.GraalCompilerTest; -import jdk.graal.compiler.lir.jtt.LIRTest; -import jdk.graal.compiler.lir.jtt.LIRTestSpecification; import jdk.graal.compiler.core.common.CompilationIdentifier; import jdk.graal.compiler.core.common.LIRKind; import jdk.graal.compiler.core.common.spi.ForeignCallSignature; import jdk.graal.compiler.core.common.type.DataPointerConstant; +import jdk.graal.compiler.core.test.GraalCompilerTest; import jdk.graal.compiler.debug.DebugContext; import jdk.graal.compiler.hotspot.HotSpotBackend; import jdk.graal.compiler.hotspot.HotSpotForeignCallLinkage; @@ -55,6 +57,8 @@ import jdk.graal.compiler.lir.asm.ArrayDataPointerConstant; import jdk.graal.compiler.lir.asm.CompilationResultBuilder; import jdk.graal.compiler.lir.gen.LIRGeneratorTool; +import jdk.graal.compiler.lir.jtt.LIRTest; +import jdk.graal.compiler.lir.jtt.LIRTestSpecification; import jdk.graal.compiler.nodes.StructuredGraph; import jdk.graal.compiler.nodes.extended.ForeignCallNode; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration; @@ -64,10 +68,6 @@ import jdk.graal.compiler.options.OptionValues; import jdk.graal.compiler.replacements.ReplacementsImpl; import jdk.graal.compiler.replacements.classfile.ClassfileBytecodeProvider; -import org.junit.Assume; -import org.junit.Before; -import org.junit.Test; - import jdk.vm.ci.amd64.AMD64; import jdk.vm.ci.amd64.AMD64.CPUFeature; import jdk.vm.ci.amd64.AMD64Kind; @@ -200,7 +200,7 @@ protected StructuredGraph buildInitialGraph(DebugContext debug, CompilationIdent // Build the snippet graph directly since snippet registration is closed at this point. ReplacementsImpl d = (ReplacementsImpl) providers.getReplacements(); MetaAccessProvider metaAccess = d.getProviders().getMetaAccess(); - BytecodeProvider bytecodes = new ClassfileBytecodeProvider(metaAccess, d.snippetReflection, ClassLoader.getSystemClassLoader()); + BytecodeProvider bytecodes = new ClassfileBytecodeProvider(metaAccess, d.getProviders().getSnippetReflection(), ClassLoader.getSystemClassLoader()); return d.makeGraph(debug, bytecodes, method, args, nonNullParameters, null, false, null); } } diff --git a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/ReplacementsTest.java b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/ReplacementsTest.java index 93697ffc3a57..9ecb8532f5d3 100644 --- a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/ReplacementsTest.java +++ b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/ReplacementsTest.java @@ -27,13 +27,13 @@ import java.lang.reflect.Executable; import java.lang.reflect.Field; +import org.junit.Assert; +import org.junit.Test; + import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.test.GraalCompilerTest; import jdk.graal.compiler.replacements.ReplacementsImpl; import jdk.graal.compiler.replacements.classfile.ClassfileBytecodeProvider; -import org.junit.Assert; -import org.junit.Test; - import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.MetaAccessProvider; @@ -50,7 +50,7 @@ public class ReplacementsTest extends GraalCompilerTest { protected final ClassfileBytecodeProvider getSystemClassLoaderBytecodeProvider() { ReplacementsImpl d = (ReplacementsImpl) getReplacements(); MetaAccessProvider metaAccess = d.getProviders().getMetaAccess(); - ClassfileBytecodeProvider bytecodeProvider = new ClassfileBytecodeProvider(metaAccess, d.snippetReflection, ClassLoader.getSystemClassLoader()); + ClassfileBytecodeProvider bytecodeProvider = new ClassfileBytecodeProvider(metaAccess, d.getProviders().getSnippetReflection(), ClassLoader.getSystemClassLoader()); return bytecodeProvider; } diff --git a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/SnippetsTest.java b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/SnippetsTest.java index 96b6d9d45288..b6dccb86d543 100644 --- a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/SnippetsTest.java +++ b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/SnippetsTest.java @@ -47,7 +47,7 @@ public abstract class SnippetsTest extends ReplacementsTest { protected SnippetsTest() { ReplacementsImpl d = (ReplacementsImpl) getReplacements(); bytecodeProvider = getSystemClassLoaderBytecodeProvider(); - installer = new ReplacementsImpl(null, d.getProviders(), d.snippetReflection, bytecodeProvider, d.target) { + installer = new ReplacementsImpl(null, d.getProviders(), bytecodeProvider, d.target) { @Override protected GraphMaker createGraphMaker(ResolvedJavaMethod substitute, ResolvedJavaMethod original) { diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/EncodedSnippets.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/EncodedSnippets.java index 761b9647988c..9b985fbf5cc1 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/EncodedSnippets.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/EncodedSnippets.java @@ -24,9 +24,9 @@ */ package jdk.graal.compiler.hotspot; -import static jdk.vm.ci.services.Services.IS_IN_NATIVE_IMAGE; import static jdk.graal.compiler.hotspot.HotSpotReplacementsImpl.isGraalClass; import static jdk.graal.compiler.nodes.graphbuilderconf.IntrinsicContext.CompilationContext.INLINE_AFTER_PARSING; +import static jdk.vm.ci.services.Services.IS_IN_NATIVE_IMAGE; import java.lang.reflect.Executable; import java.lang.reflect.Field; @@ -35,6 +35,7 @@ import java.util.function.Consumer; import org.graalvm.collections.UnmodifiableEconomicMap; + import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.bytecode.BytecodeProvider; import jdk.graal.compiler.bytecode.ResolvedJavaMethodBytecode; @@ -60,7 +61,6 @@ import jdk.graal.compiler.replacements.ConstantBindingParameterPlugin; import jdk.graal.compiler.replacements.PEGraphDecoder; import jdk.graal.compiler.replacements.PartialIntrinsicCallTargetNode; - import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.MetaAccessProvider; @@ -297,7 +297,7 @@ static StructuredGraph decodeSnippetGraph(SymbolicEncodedGraph encodedGraph, Res ParameterPlugin parameterPlugin = null; if (args != null) { MetaAccessProvider meta = HotSpotReplacementsImpl.noticeTypes(providers.getMetaAccess()); - SnippetReflectionProvider snippetReflection = replacements.snippetReflection; + SnippetReflectionProvider snippetReflection = replacements.getProviders().getSnippetReflection(); if (IS_IN_NATIVE_IMAGE) { snippetReflection = new LibGraalSnippetReflectionProvider(snippetReflection); } diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotBackendFactory.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotBackendFactory.java index 25be22865bbf..0f2f29c0c634 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotBackendFactory.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotBackendFactory.java @@ -96,8 +96,8 @@ protected HotSpotMetaAccessExtensionProvider createMetaAccessExtensionProvider() return new HotSpotMetaAccessExtensionProvider(); } - protected HotSpotReplacementsImpl createReplacements(TargetDescription target, HotSpotProviders p, HotSpotSnippetReflectionProvider snippetReflection, BytecodeProvider bytecodeProvider) { - return new HotSpotReplacementsImpl(p, snippetReflection, bytecodeProvider, target); + protected HotSpotReplacementsImpl createReplacements(TargetDescription target, HotSpotProviders p, BytecodeProvider bytecodeProvider) { + return new HotSpotReplacementsImpl(p, bytecodeProvider, target); } protected ClassfileBytecodeProvider createBytecodeProvider(MetaAccessProvider metaAccess, HotSpotSnippetReflectionProvider snippetReflection) { @@ -193,7 +193,7 @@ public final HotSpotBackend createBackend(HotSpotGraalRuntimeProvider graalRunti snippetReflection, wordTypes, stampProvider, platformConfigurationProvider, metaAccessExtensionProvider, loopsDataProvider, config); HotSpotReplacementsImpl replacements; try (InitTimer rt = timer("create Replacements provider")) { - replacements = createReplacements(target, providers, snippetReflection, bytecodeProvider); + replacements = createReplacements(target, providers, bytecodeProvider); providers = replacements.getProviders(); replacements.maybeInitializeEncoder(); } diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotReplacementsImpl.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotReplacementsImpl.java index 4087865aa6fa..04e56b2fae07 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotReplacementsImpl.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotReplacementsImpl.java @@ -29,16 +29,16 @@ import java.util.BitSet; -import jdk.graal.compiler.hotspot.meta.HotSpotProviders; -import jdk.graal.compiler.hotspot.meta.HotSpotWordOperationPlugin; import org.graalvm.collections.EconomicSet; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; + import jdk.graal.compiler.bytecode.Bytecode; import jdk.graal.compiler.bytecode.BytecodeProvider; import jdk.graal.compiler.bytecode.ResolvedJavaMethodBytecode; import jdk.graal.compiler.debug.DebugContext; import jdk.graal.compiler.debug.GraalError; import jdk.graal.compiler.graph.NodeSourcePosition; +import jdk.graal.compiler.hotspot.meta.HotSpotProviders; +import jdk.graal.compiler.hotspot.meta.HotSpotWordOperationPlugin; import jdk.graal.compiler.hotspot.word.HotSpotOperation; import jdk.graal.compiler.java.GraphBuilderPhase.Instance; import jdk.graal.compiler.nodes.Invoke; @@ -59,7 +59,6 @@ import jdk.graal.compiler.printer.GraalDebugHandlersFactory; import jdk.graal.compiler.replacements.IntrinsicGraphBuilder; import jdk.graal.compiler.replacements.ReplacementsImpl; - import jdk.vm.ci.code.TargetDescription; import jdk.vm.ci.common.NativeImageReinitialize; import jdk.vm.ci.meta.MetaAccessProvider; @@ -71,12 +70,12 @@ * them. */ public class HotSpotReplacementsImpl extends ReplacementsImpl { - public HotSpotReplacementsImpl(HotSpotProviders providers, SnippetReflectionProvider snippetReflection, BytecodeProvider bytecodeProvider, TargetDescription target) { - super(new GraalDebugHandlersFactory(snippetReflection), providers, snippetReflection, bytecodeProvider, target); + public HotSpotReplacementsImpl(HotSpotProviders providers, BytecodeProvider bytecodeProvider, TargetDescription target) { + super(new GraalDebugHandlersFactory(providers.getSnippetReflection()), providers, bytecodeProvider, target); } HotSpotReplacementsImpl(HotSpotReplacementsImpl replacements, HotSpotProviders providers) { - super(new GraalDebugHandlersFactory(replacements.snippetReflection), providers, replacements.snippetReflection, + super(new GraalDebugHandlersFactory(replacements.getProviders().getSnippetReflection()), providers, replacements.getDefaultReplacementBytecodeProvider(), replacements.target); } diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/SymbolicSnippetEncoder.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/SymbolicSnippetEncoder.java index 557bf1e60a92..a402fe7a7a68 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/SymbolicSnippetEncoder.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/SymbolicSnippetEncoder.java @@ -41,11 +41,10 @@ import java.util.Set; import java.util.function.BiFunction; -import jdk.graal.compiler.hotspot.meta.HotSpotProviders; -import jdk.graal.compiler.hotspot.word.HotSpotWordTypes; import org.graalvm.collections.EconomicMap; import org.graalvm.collections.EconomicSet; import org.graalvm.collections.MapCursor; + import jdk.graal.compiler.api.replacements.Fold; import jdk.graal.compiler.api.replacements.Snippet; import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; @@ -63,7 +62,9 @@ import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.graph.NodeMap; import jdk.graal.compiler.graph.NodeSourcePosition; +import jdk.graal.compiler.hotspot.meta.HotSpotProviders; import jdk.graal.compiler.hotspot.stubs.ForeignCallStub; +import jdk.graal.compiler.hotspot.word.HotSpotWordTypes; import jdk.graal.compiler.java.BytecodeParser; import jdk.graal.compiler.java.GraphBuilderPhase; import jdk.graal.compiler.nodeinfo.Verbosity; @@ -108,7 +109,6 @@ import jdk.graal.compiler.replacements.SnippetTemplate; import jdk.graal.compiler.replacements.classfile.ClassfileBytecode; import jdk.graal.compiler.word.WordTypes; - import jdk.vm.ci.code.Architecture; import jdk.vm.ci.code.TargetDescription; import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime; @@ -247,12 +247,6 @@ static final class SnippetCounterPlugin implements NodePlugin { String snippetCounterName = 'L' + SnippetCounter.class.getName().replace('.', '/') + ';'; String snippetIntegerHistogramName = 'L' + SnippetIntegerHistogram.class.getName().replace('.', '/') + ';'; - private final ReplacementsImpl snippetReplacements; - - private SnippetCounterPlugin(ReplacementsImpl snippetReplacements) { - this.snippetReplacements = snippetReplacements; - } - @Override public boolean handleLoadField(GraphBuilderContext b, ValueNode object, ResolvedJavaField field) { if (field.getName().equals("group") && field.getDeclaringClass().getName().equals(snippetCounterName)) { @@ -260,12 +254,12 @@ public boolean handleLoadField(GraphBuilderContext b, ValueNode object, Resolved return true; } if (field.getType().getName().equals(snippetCounterName)) { - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReplacements.snippetReflection.forObject(SnippetCounter.DISABLED_COUNTER), b.getMetaAccess())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(SnippetCounter.DISABLED_COUNTER), b.getMetaAccess())); return true; } if (field.getType().getName().equals(snippetIntegerHistogramName)) { - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReplacements.snippetReflection.forObject(SnippetIntegerHistogram.DISABLED_COUNTER), b.getMetaAccess())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(SnippetIntegerHistogram.DISABLED_COUNTER), b.getMetaAccess())); return true; } return false; @@ -366,14 +360,13 @@ private boolean verifySnippetEncodeDecode(DebugContext debug, ResolvedJavaMethod HotSpotProviders originalProvider = originalReplacements.getProviders(); - SnippetReflectionProvider snippetReflection = originalProvider.getSnippetReflection(); SymbolicSnippetEncoder.HotSpotSubstrateConstantReflectionProvider constantReflection = new SymbolicSnippetEncoder.HotSpotSubstrateConstantReflectionProvider( originalProvider.getConstantReflection()); HotSpotProviders newProviders = new HotSpotProviders(originalProvider.getMetaAccess(), originalProvider.getCodeCache(), constantReflection, originalProvider.getConstantFieldProvider(), originalProvider.getForeignCalls(), originalProvider.getLowerer(), null, originalProvider.getSuites(), - originalProvider.getRegisters(), snippetReflection, originalProvider.getWordTypes(), originalProvider.getStampProvider(), + originalProvider.getRegisters(), originalProvider.getSnippetReflection(), originalProvider.getWordTypes(), originalProvider.getStampProvider(), originalProvider.getPlatformConfigurationProvider(), originalProvider.getMetaAccessExtensionProvider(), originalProvider.getLoopsDataProvider(), originalProvider.getConfig()); - HotSpotSnippetReplacementsImpl filteringReplacements = new HotSpotSnippetReplacementsImpl(newProviders, snippetReflection, + HotSpotSnippetReplacementsImpl filteringReplacements = new HotSpotSnippetReplacementsImpl(newProviders, originalProvider.getReplacements().getDefaultReplacementBytecodeProvider(), originalProvider.getCodeCache().getTarget()); filteringReplacements.setGraphBuilderPlugins(originalProvider.getReplacements().getGraphBuilderPlugins()); try (DebugContext.Scope scope = debug.scope("VerifySnippetEncodeDecode", graph)) { @@ -418,7 +411,7 @@ private synchronized EncodedSnippets encodeSnippets(OptionValues options) { snippetReplacements.setGraphBuilderPlugins(copy); copy.clearInlineInvokePlugins(); copy.appendInlineInvokePlugin(new SnippetInlineInvokePlugin()); - copy.appendNodePlugin(new SnippetCounterPlugin(snippetReplacements)); + copy.appendNodePlugin(new SnippetCounterPlugin()); EconomicMap preparedSnippetGraphs = EconomicMap.create(); MapCursor> cursor = pendingSnippetGraphs.getEntries(); @@ -979,8 +972,8 @@ class HotSpotSnippetReplacementsImpl extends HotSpotReplacementsImpl { super(replacements, providers); } - HotSpotSnippetReplacementsImpl(HotSpotProviders providers, SnippetReflectionProvider snippetReflection, BytecodeProvider bytecodeProvider, TargetDescription target) { - super(providers, snippetReflection, bytecodeProvider, target); + HotSpotSnippetReplacementsImpl(HotSpotProviders providers, BytecodeProvider bytecodeProvider, TargetDescription target) { + super(providers, bytecodeProvider, target); } @Override diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/ReplacementsImpl.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/ReplacementsImpl.java index 1c47fb7f92f8..a441fdcf48b8 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/ReplacementsImpl.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/ReplacementsImpl.java @@ -109,7 +109,6 @@ public void setProviders(Providers providers) { } protected Providers providers; - public final SnippetReflectionProvider snippetReflection; public final TargetDescription target; protected GraphBuilderConfiguration.Plugins graphBuilderPlugins; private final DebugHandlersFactory debugHandlersFactory; @@ -151,7 +150,7 @@ public T getInjectedArgument(Class capability) { return (T) getProviders().getForeignCalls(); } if (capability.equals(SnippetReflectionProvider.class)) { - return (T) snippetReflection; + return (T) getProviders().getSnippetReflection(); } if (capability.isAssignableFrom(WordTypes.class)) { return (T) getProviders().getWordTypes(); @@ -237,10 +236,9 @@ public void notifyNotInlined(GraphBuilderContext b, ResolvedJavaMethod method, I private final EconomicMap snippetTemplateCache; @SuppressWarnings("this-escape") - public ReplacementsImpl(DebugHandlersFactory debugHandlersFactory, Providers providers, SnippetReflectionProvider snippetReflection, BytecodeProvider bytecodeProvider, + public ReplacementsImpl(DebugHandlersFactory debugHandlersFactory, Providers providers, BytecodeProvider bytecodeProvider, TargetDescription target) { this.providers = providers.copyWith(this); - this.snippetReflection = snippetReflection; this.target = target; this.graphs = new ConcurrentHashMap<>(); this.snippetTemplateCache = EconomicMap.create(Equivalence.DEFAULT); @@ -536,7 +534,7 @@ protected StructuredGraph buildInitialGraph(DebugContext debug, BytecodeProvider Plugins plugins = new Plugins(replacements.graphBuilderPlugins); GraphBuilderConfiguration config = GraphBuilderConfiguration.getSnippetDefault(plugins); if (args != null) { - plugins.prependParameterPlugin(new ConstantBindingParameterPlugin(args, metaAccess, replacements.snippetReflection)); + plugins.prependParameterPlugin(new ConstantBindingParameterPlugin(args, metaAccess, replacements.getProviders().getSnippetReflection())); } if (nonNullParameters != null && !nonNullParameters.isEmpty()) { plugins.appendParameterPlugin(new NonNullParameterPlugin(nonNullParameters)); diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/TruffleCompilerImpl.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/TruffleCompilerImpl.java index 02b783c2d2ab..030ad5638a95 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/TruffleCompilerImpl.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/TruffleCompilerImpl.java @@ -311,7 +311,7 @@ public void initialize(TruffleCompilable compilable, boolean firstInitialization // Hook for SVM protected TruffleTier newTruffleTier(OptionValues options) { return new TruffleTier(options, partialEvaluator, - new InstrumentationSuite(partialEvaluator.instrumentationCfg, config.snippetReflection(), partialEvaluator.getInstrumentation()), + new InstrumentationSuite(partialEvaluator.instrumentationCfg, partialEvaluator.getInstrumentation()), new PostPartialEvaluationSuite(options, TruffleCompilerOptions.IterativePartialEscape.getValue(options))); } diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentBranchesPhase.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentBranchesPhase.java index 52c183a058d3..01dfe30dc97e 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentBranchesPhase.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentBranchesPhase.java @@ -24,15 +24,13 @@ */ package jdk.graal.compiler.truffle.phases; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.debug.MethodFilter; import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.graph.NodeSourcePosition; import jdk.graal.compiler.nodes.IfNode; import jdk.graal.compiler.nodes.StructuredGraph; - -import jdk.vm.ci.meta.JavaConstant; import jdk.graal.compiler.truffle.TruffleTierContext; +import jdk.vm.ci.meta.JavaConstant; /** * Instruments {@link IfNode}s in the graph, by adding execution counters to the true and the false @@ -58,8 +56,8 @@ public class InstrumentBranchesPhase extends InstrumentPhase { private final boolean isInstrumentPerInlineSite; - public InstrumentBranchesPhase(SnippetReflectionProvider snippetReflection, Instrumentation instrumentation, boolean instrumentPerInlineSite) { - super(snippetReflection, instrumentation); + public InstrumentBranchesPhase(Instrumentation instrumentation, boolean instrumentPerInlineSite) { + super(instrumentation); isInstrumentPerInlineSite = instrumentPerInlineSite; } diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentPhase.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentPhase.java index 27501306fc92..c807d831838f 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentPhase.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentPhase.java @@ -38,7 +38,6 @@ import java.util.List; import java.util.Map; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.type.StampFactory; import jdk.graal.compiler.core.common.type.TypeReference; import jdk.graal.compiler.debug.MethodFilter; @@ -57,7 +56,6 @@ import jdk.graal.compiler.truffle.KnownTruffleTypes; import jdk.graal.compiler.truffle.TruffleCompilerOptions; import jdk.graal.compiler.truffle.TruffleTierContext; - import jdk.vm.ci.code.CodeUtil; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; @@ -66,10 +64,8 @@ public abstract class InstrumentPhase extends BasePhase { private final Instrumentation instrumentation; - protected final SnippetReflectionProvider snippetReflection; - public InstrumentPhase(SnippetReflectionProvider snippetReflection, Instrumentation instrumentation) { - this.snippetReflection = snippetReflection; + public InstrumentPhase(Instrumentation instrumentation) { this.instrumentation = instrumentation; } @@ -104,7 +100,7 @@ public float codeSizeIncrease() { @Override protected void run(StructuredGraph graph, TruffleTierContext context) { - JavaConstant tableConstant = snippetReflection.forObject(instrumentation.getAccessTable()); + JavaConstant tableConstant = context.getSnippetReflection().forObject(instrumentation.getAccessTable()); try { instrumentGraph(graph, context, tableConstant); } catch (Exception e) { diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentTruffleBoundariesPhase.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentTruffleBoundariesPhase.java index 1e976a665b26..ab085f02c53a 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentTruffleBoundariesPhase.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentTruffleBoundariesPhase.java @@ -24,7 +24,8 @@ */ package jdk.graal.compiler.truffle.phases; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import com.oracle.truffle.compiler.TruffleCompilerRuntime.InlineKind; + import jdk.graal.compiler.debug.MethodFilter; import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.graph.NodeSourcePosition; @@ -32,9 +33,6 @@ import jdk.graal.compiler.nodes.Invoke; import jdk.graal.compiler.nodes.StructuredGraph; import jdk.graal.compiler.truffle.TruffleTierContext; - -import com.oracle.truffle.compiler.TruffleCompilerRuntime.InlineKind; - import jdk.vm.ci.meta.JavaConstant; /** @@ -67,8 +65,8 @@ public class InstrumentTruffleBoundariesPhase extends InstrumentPhase { private final boolean isInstrumentPerInlineSite; - public InstrumentTruffleBoundariesPhase(SnippetReflectionProvider snippetReflection, Instrumentation instrumentation, boolean instrumentPerInlineSite) { - super(snippetReflection, instrumentation); + public InstrumentTruffleBoundariesPhase(Instrumentation instrumentation, boolean instrumentPerInlineSite) { + super(instrumentation); isInstrumentPerInlineSite = instrumentPerInlineSite; } diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentationSuite.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentationSuite.java index 96fbde04a995..5de7ddabcdc6 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentationSuite.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/phases/InstrumentationSuite.java @@ -24,19 +24,17 @@ */ package jdk.graal.compiler.truffle.phases; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.phases.PhaseSuite; import jdk.graal.compiler.truffle.TruffleTierContext; public class InstrumentationSuite extends PhaseSuite { @SuppressWarnings("this-escape") - public InstrumentationSuite(InstrumentPhase.InstrumentationConfiguration instrumentationCfg, SnippetReflectionProvider snippetReflection, - InstrumentPhase.Instrumentation instrumentation) { + public InstrumentationSuite(InstrumentPhase.InstrumentationConfiguration instrumentationCfg, InstrumentPhase.Instrumentation instrumentation) { if (instrumentationCfg.instrumentBranches) { - appendPhase(new InstrumentBranchesPhase(snippetReflection, instrumentation, instrumentationCfg.instrumentBranchesPerInlineSite)); + appendPhase(new InstrumentBranchesPhase(instrumentation, instrumentationCfg.instrumentBranchesPerInlineSite)); } if (instrumentationCfg.instrumentBoundaries) { - appendPhase(new InstrumentTruffleBoundariesPhase(snippetReflection, instrumentation, instrumentationCfg.instrumentBoundariesPerInlineSite)); + appendPhase(new InstrumentTruffleBoundariesPhase(instrumentation, instrumentationCfg.instrumentBoundariesPerInlineSite)); } } } diff --git a/substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/AMD64CalleeSavedRegisters.java b/substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/AMD64CalleeSavedRegisters.java index 4cf3ed21d0f1..90f4716541ac 100644 --- a/substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/AMD64CalleeSavedRegisters.java +++ b/substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/AMD64CalleeSavedRegisters.java @@ -59,7 +59,6 @@ import com.oracle.svm.core.util.VMError; import jdk.graal.compiler.api.replacements.Fold; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.asm.Label; import jdk.graal.compiler.asm.amd64.AMD64Address; import jdk.graal.compiler.asm.amd64.AMD64Assembler; @@ -455,8 +454,7 @@ private AMD64BaseAssembler.OperandSize getSize() { @Platforms(Platform.HOSTED_ONLY.class) private AMD64Address getFeatureMapAddress() { - SnippetReflectionProvider snippetReflection = crb.getSnippetReflection(); - JavaConstant object = snippetReflection.forObject(RuntimeCPUFeatureCheckImpl.instance()); + JavaConstant object = crb.getSnippetReflection().forObject(RuntimeCPUFeatureCheckImpl.instance()); int fieldOffset = fieldOffset(RuntimeCPUFeatureCheckImpl.getMaskField(crb.getMetaAccess())); GraalError.guarantee(ConfigurationValues.getTarget().inlineObjects, "Dynamic feature check for callee saved registers requires inlined objects"); Register heapBase = ReservedRegisters.singleton().getHeapBaseRegister(); diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/StaticFieldsSupport.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/StaticFieldsSupport.java index efd44faca958..cde82056ae55 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/StaticFieldsSupport.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/StaticFieldsSupport.java @@ -29,7 +29,17 @@ import java.util.Objects; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import org.graalvm.nativeimage.ImageSingletons; +import org.graalvm.nativeimage.Platform; +import org.graalvm.nativeimage.Platforms; +import org.graalvm.word.LocationIdentity; + +import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; +import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton; +import com.oracle.svm.core.feature.InternalFeature; +import com.oracle.svm.core.meta.SharedField; +import com.oracle.svm.core.util.VMError; + import jdk.graal.compiler.core.common.type.StampFactory; import jdk.graal.compiler.graph.NodeClass; import jdk.graal.compiler.nodeinfo.NodeInfo; @@ -42,17 +52,6 @@ import jdk.graal.compiler.nodes.spi.Lowerable; import jdk.graal.compiler.nodes.spi.LoweringTool; import jdk.graal.compiler.phases.util.Providers; -import org.graalvm.nativeimage.ImageSingletons; -import org.graalvm.nativeimage.Platform; -import org.graalvm.nativeimage.Platforms; -import org.graalvm.word.LocationIdentity; - -import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; -import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton; -import com.oracle.svm.core.feature.InternalFeature; -import com.oracle.svm.core.meta.SharedField; -import com.oracle.svm.core.util.VMError; - import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.ResolvedJavaMethod; @@ -169,7 +168,7 @@ public void lower(LoweringTool tool) { final class StaticFieldsFeature implements InternalFeature { @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { Registration r = new Registration(plugins.getInvocationPlugins(), StaticFieldsSupport.class); r.register(new RequiredInvocationPlugin("getStaticObjectFields") { @Override diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/cpufeature/RuntimeCPUFeatureCheckImpl.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/cpufeature/RuntimeCPUFeatureCheckImpl.java index dda73aa00256..149e256948ed 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/cpufeature/RuntimeCPUFeatureCheckImpl.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/cpufeature/RuntimeCPUFeatureCheckImpl.java @@ -47,10 +47,8 @@ import com.oracle.svm.util.ReflectionUtil; import jdk.graal.compiler.api.replacements.Fold; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.NumUtil; import jdk.graal.compiler.debug.GraalError; -import jdk.graal.compiler.graph.Node.InjectedNodeParameter; import jdk.graal.compiler.graph.Node.NodeIntrinsicFactory; import jdk.graal.compiler.nodes.ConstantNode; import jdk.graal.compiler.nodes.LogicNode; @@ -265,8 +263,8 @@ private static EnumSet toEnumSet(Enum first, Enum... rest) { return EnumSet.of(first, rest); } - public static boolean intrinsify(GraphBuilderContext b, @InjectedNodeParameter SnippetReflectionProvider snippetReflection, Enum first, Enum... rest) { - return buildRuntimeCPUFeatureCheck(b, snippetReflection, toEnumSet(first, rest)); + public static boolean intrinsify(GraphBuilderContext b, Enum first, Enum... rest) { + return buildRuntimeCPUFeatureCheck(b, toEnumSet(first, rest)); } /** @@ -279,7 +277,7 @@ public static boolean intrinsify(GraphBuilderContext b, @InjectedNodeParameter S * The root node built by this intrinsic includes a branch probability annotation. It must be * used directly as the condition of an {@code if} statement. */ - private static boolean buildRuntimeCPUFeatureCheck(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, EnumSet allFeatures) { + private static boolean buildRuntimeCPUFeatureCheck(GraphBuilderContext b, EnumSet allFeatures) { // remove static features from the set EnumSet features = removeStaticFeatures(allFeatures); if (features.isEmpty()) { @@ -301,7 +299,7 @@ private static boolean buildRuntimeCPUFeatureCheck(GraphBuilderContext b, Snippe */ MetaAccessProvider metaAccess = b.getMetaAccess(); ResolvedJavaField field = getMaskField(metaAccess); - ConstantNode object = b.add(ConstantNode.forConstant(snippetReflection.forObject(instance()), metaAccess)); + ConstantNode object = b.add(ConstantNode.forConstant(b.getSnippetReflection().forObject(instance()), metaAccess)); ValueNode featureMask = b.add(LoadFieldNode.create(null, object, field)); int mask = instance().computeFeatureMask(features); GraalError.guarantee(JavaKind.Int.equals(field.getType().getJavaKind()), "Expected field to be an int"); diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/feature/InternalFeature.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/feature/InternalFeature.java index b7ef1b11c16c..58193beaac06 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/feature/InternalFeature.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/feature/InternalFeature.java @@ -26,12 +26,6 @@ import java.util.Map; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; -import jdk.graal.compiler.graph.Node; -import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; -import jdk.graal.compiler.options.OptionValues; -import jdk.graal.compiler.phases.tiers.Suites; -import jdk.graal.compiler.phases.util.Providers; import org.graalvm.nativeimage.hosted.Feature; import com.oracle.svm.core.ParsingReason; @@ -39,6 +33,12 @@ import com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider; import com.oracle.svm.core.graal.snippets.NodeLoweringProvider; +import jdk.graal.compiler.graph.Node; +import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; +import jdk.graal.compiler.options.OptionValues; +import jdk.graal.compiler.phases.tiers.Suites; +import jdk.graal.compiler.phases.util.Providers; + public interface InternalFeature extends Feature { /** @@ -54,11 +54,10 @@ default void registerForeignCalls(SubstrateForeignCallsProvider foreignCalls) { * Called to register Graal invocation plugins. * * @param providers Providers that the lowering can use. - * @param snippetReflection Snippet reflection providers. * @param plugins Contains the invocation plugins to add to. * @param reason The parsing phase that the plugins are registered for */ - default void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, Plugins plugins, ParsingReason reason) { + default void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { } /** @@ -91,12 +90,11 @@ default void registerLowerings(RuntimeConfiguration runtimeConfig, OptionValues * runtime compilation. * * @param providers Providers that the lowering can use. - * @param snippetReflection Snippet reflection providers. * @param suites The Graal compilation suites to add to. * @param hosted True if registering for ahead-of-time compilation, false if registering for * runtime compilation. */ - default void registerGraalPhases(Providers providers, SnippetReflectionProvider snippetReflection, Suites suites, boolean hosted) { + default void registerGraalPhases(Providers providers, Suites suites, boolean hosted) { } /** diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/jdk/JDKIntrinsicsFeature.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/jdk/JDKIntrinsicsFeature.java index 96188ca3e66a..93d6812def64 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/jdk/JDKIntrinsicsFeature.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/jdk/JDKIntrinsicsFeature.java @@ -26,7 +26,13 @@ import java.util.Map; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import com.oracle.svm.core.ParsingReason; +import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; +import com.oracle.svm.core.feature.InternalFeature; +import com.oracle.svm.core.graal.meta.RuntimeConfiguration; +import com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider; +import com.oracle.svm.core.graal.snippets.NodeLoweringProvider; + import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugins; @@ -35,13 +41,6 @@ import jdk.graal.compiler.phases.util.Providers; import jdk.graal.compiler.replacements.arraycopy.ArrayCopySnippets; -import com.oracle.svm.core.ParsingReason; -import com.oracle.svm.core.feature.InternalFeature; -import com.oracle.svm.core.graal.meta.RuntimeConfiguration; -import com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider; -import com.oracle.svm.core.graal.snippets.NodeLoweringProvider; -import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; - @AutomaticallyRegisteredFeature final class JDKIntrinsicsFeature implements InternalFeature { @@ -60,7 +59,7 @@ public void registerLowerings(RuntimeConfiguration runtimeConfig, OptionValues o } @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { registerSystemPlugins(plugins.getInvocationPlugins()); } diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/RuntimeConfiguration.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/RuntimeConfiguration.java index 6e39ecec67b8..a058939c5b52 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/RuntimeConfiguration.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/RuntimeConfiguration.java @@ -34,7 +34,6 @@ import com.oracle.svm.core.graal.meta.SubstrateRegisterConfig.ConfigKind; import com.oracle.svm.core.meta.SharedMethod; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.debug.DebugHandlersFactory; import jdk.graal.compiler.phases.util.Providers; import jdk.vm.ci.meta.ResolvedJavaMethod; @@ -45,15 +44,12 @@ public final class RuntimeConfiguration { private final Providers providers; - private final SnippetReflectionProvider snippetReflection; private final EnumMap backends; private final Iterable debugHandlersFactories; @Platforms(Platform.HOSTED_ONLY.class) - public RuntimeConfiguration(Providers providers, SnippetReflectionProvider snippetReflection, EnumMap backends, - Iterable debugHandlersFactories) { + public RuntimeConfiguration(Providers providers, EnumMap backends, Iterable debugHandlersFactories) { this.providers = providers; - this.snippetReflection = snippetReflection; this.backends = backends; this.debugHandlersFactories = debugHandlersFactories; @@ -85,8 +81,4 @@ public SubstrateBackend lookupBackend(ResolvedJavaMethod method) { public SubstrateBackend getBackendForNormalMethod() { return backends.get(ConfigKind.NORMAL); } - - public SnippetReflectionProvider getSnippetReflection() { - return snippetReflection; - } } diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/SubstrateReplacements.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/SubstrateReplacements.java index 1bd919d8fddb..33fe95470967 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/SubstrateReplacements.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/SubstrateReplacements.java @@ -54,7 +54,6 @@ import com.oracle.svm.core.util.VMError; import jdk.graal.compiler.api.replacements.Snippet; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.bytecode.BytecodeProvider; import jdk.graal.compiler.core.common.GraalOptions; import jdk.graal.compiler.core.common.type.Stamp; @@ -152,9 +151,9 @@ public InlineInfo shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod m private Map snippetStartOffsets; @Platforms(Platform.HOSTED_ONLY.class) - public SubstrateReplacements(Providers providers, SnippetReflectionProvider snippetReflection, BytecodeProvider bytecodeProvider, TargetDescription target, GraphMakerFactory graphMakerFactory) { + public SubstrateReplacements(Providers providers, BytecodeProvider bytecodeProvider, TargetDescription target, GraphMakerFactory graphMakerFactory) { // Snippets cannot have optimistic assumptions. - super(new GraalDebugHandlersFactory(snippetReflection), providers, snippetReflection, bytecodeProvider, target); + super(new GraalDebugHandlersFactory(providers.getSnippetReflection()), providers, bytecodeProvider, target); this.builder = new Builder(graphMakerFactory); } @@ -214,7 +213,7 @@ public StructuredGraph getSnippet(ResolvedJavaMethod method, ResolvedJavaMethod ParameterPlugin parameterPlugin = null; if (args != null) { - parameterPlugin = new ConstantBindingParameterPlugin(args, providers.getMetaAccess(), snippetReflection); + parameterPlugin = new ConstantBindingParameterPlugin(args, providers.getMetaAccess(), providers.getSnippetReflection()); } OptionValues optionValues = new OptionValues(options, GraalOptions.TraceInlining, GraalOptions.TraceInliningForStubsAndSnippets.getValue(options), diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java index 84c30e4b4d3e..d73c96e2a61a 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java @@ -38,7 +38,6 @@ import com.oracle.svm.core.thread.VMThreads.StatusSupport; import com.oracle.svm.core.util.VMError; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.CompilationIdentifier; import jdk.graal.compiler.core.common.spi.ForeignCallDescriptor; import jdk.graal.compiler.core.common.type.Stamp; @@ -291,8 +290,7 @@ public ConstantNode createInt(int value) { } public ConstantNode createObject(Object value) { - SnippetReflectionProvider snippetReflection = getProviders().getSnippetReflection(); - return ConstantNode.forConstant(snippetReflection.forObject(value), getMetaAccess(), graph); + return ConstantNode.forConstant(getSnippetReflection().forObject(value), getMetaAccess(), graph); } public ValueNode createBoxing(ValueNode value, JavaKind kind, ResolvedJavaType targetType) { diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/StackOverflowCheckFeature.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/StackOverflowCheckFeature.java index 359102e88cac..225aace71405 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/StackOverflowCheckFeature.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/StackOverflowCheckFeature.java @@ -28,14 +28,6 @@ import java.util.Map; import java.util.function.Predicate; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; -import jdk.graal.compiler.graph.Node; -import jdk.graal.compiler.options.OptionValues; -import jdk.graal.compiler.phases.BasePhase; -import jdk.graal.compiler.phases.common.LoweringPhase; -import jdk.graal.compiler.phases.tiers.MidTierContext; -import jdk.graal.compiler.phases.tiers.Suites; -import jdk.graal.compiler.phases.util.Providers; import org.graalvm.nativeimage.ImageSingletons; import org.graalvm.nativeimage.Platforms; import org.graalvm.nativeimage.impl.InternalPlatform; @@ -47,6 +39,13 @@ import com.oracle.svm.core.heap.RestrictHeapAccessCallees; import com.oracle.svm.core.stack.StackOverflowCheck; +import jdk.graal.compiler.graph.Node; +import jdk.graal.compiler.options.OptionValues; +import jdk.graal.compiler.phases.BasePhase; +import jdk.graal.compiler.phases.common.LoweringPhase; +import jdk.graal.compiler.phases.tiers.MidTierContext; +import jdk.graal.compiler.phases.tiers.Suites; +import jdk.graal.compiler.phases.util.Providers; import jdk.vm.ci.meta.ResolvedJavaMethod; @AutomaticallyRegisteredFeature @@ -59,7 +58,7 @@ public void afterRegistration(AfterRegistrationAccess access) { } @Override - public void registerGraalPhases(Providers providers, SnippetReflectionProvider snippetReflection, Suites suites, boolean hosted) { + public void registerGraalPhases(Providers providers, Suites suites, boolean hosted) { /* * There is no need to have the stack overflow check in the graph throughout most of the * compilation pipeline. Inserting it before the mid-tier lowering is done for pragmatic diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/stackvalue/StackValueFeature.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/stackvalue/StackValueFeature.java index 5fc5811f101a..d44408af042d 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/stackvalue/StackValueFeature.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/stackvalue/StackValueFeature.java @@ -27,7 +27,12 @@ import java.util.ListIterator; import java.util.Map; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; +import com.oracle.svm.core.feature.InternalFeature; +import com.oracle.svm.core.graal.meta.RuntimeConfiguration; +import com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider; +import com.oracle.svm.core.graal.snippets.NodeLoweringProvider; + import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.options.OptionValues; import jdk.graal.compiler.phases.BasePhase; @@ -38,16 +43,10 @@ import jdk.graal.compiler.phases.tiers.Suites; import jdk.graal.compiler.phases.util.Providers; -import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; -import com.oracle.svm.core.feature.InternalFeature; -import com.oracle.svm.core.graal.meta.RuntimeConfiguration; -import com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider; -import com.oracle.svm.core.graal.snippets.NodeLoweringProvider; - @AutomaticallyRegisteredFeature public class StackValueFeature implements InternalFeature { @Override - public void registerGraalPhases(Providers providers, SnippetReflectionProvider snippetReflection, Suites suites, boolean hosted) { + public void registerGraalPhases(Providers providers, Suites suites, boolean hosted) { ListIterator> midTierPos = suites.getMidTier().findPhase(FrameStateAssignmentPhase.class); midTierPos.previous(); midTierPos.add(new StackValueRecursionDepthPhase()); diff --git a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/RuntimeCPUFeatureRegion.java b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/RuntimeCPUFeatureRegion.java index 2f89ea825d65..75eac2ee1004 100644 --- a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/RuntimeCPUFeatureRegion.java +++ b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/RuntimeCPUFeatureRegion.java @@ -29,7 +29,14 @@ import java.util.Arrays; import java.util.EnumSet; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import com.oracle.svm.core.ParsingReason; +import com.oracle.svm.core.config.ConfigurationValues; +import com.oracle.svm.core.cpufeature.RuntimeCPUFeatureCheck; +import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; +import com.oracle.svm.core.feature.InternalFeature; +import com.oracle.svm.graal.aarch64.AArch64CPUFeatureRegionOp; +import com.oracle.svm.graal.amd64.AMD64CPUFeatureRegionOp; + import jdk.graal.compiler.core.common.type.StampFactory; import jdk.graal.compiler.debug.GraalError; import jdk.graal.compiler.graph.NodeClass; @@ -47,15 +54,6 @@ import jdk.graal.compiler.nodes.spi.LIRLowerable; import jdk.graal.compiler.nodes.spi.NodeLIRBuilderTool; import jdk.graal.compiler.phases.util.Providers; - -import com.oracle.svm.core.ParsingReason; -import com.oracle.svm.core.config.ConfigurationValues; -import com.oracle.svm.core.cpufeature.RuntimeCPUFeatureCheck; -import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; -import com.oracle.svm.core.feature.InternalFeature; -import com.oracle.svm.graal.aarch64.AArch64CPUFeatureRegionOp; -import com.oracle.svm.graal.amd64.AMD64CPUFeatureRegionOp; - import jdk.vm.ci.aarch64.AArch64; import jdk.vm.ci.amd64.AMD64; import jdk.vm.ci.code.Architecture; @@ -66,30 +64,30 @@ class RuntimeCPUFeatureRegionFeature implements InternalFeature { @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) { InvocationPlugins.Registration r = new InvocationPlugins.Registration(plugins.getInvocationPlugins(), RuntimeCPUFeatureRegion.class, providers.getReplacements()); r.register(new InvocationPlugin.RequiredInlineOnlyInvocationPlugin("enter", Enum.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode arg0) { - return createRegionEnterNode(providers, snippetReflection, b, arg0); + return createRegionEnterNode(b, arg0); } }); r.register(new InvocationPlugin.RequiredInlineOnlyInvocationPlugin("enter", Enum.class, Enum.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode arg0, ValueNode arg1) { - return createRegionEnterNode(providers, snippetReflection, b, arg0, arg1); + return createRegionEnterNode(b, arg0, arg1); } }); r.register(new InvocationPlugin.RequiredInlineOnlyInvocationPlugin("enter", Enum.class, Enum.class, Enum.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode arg0, ValueNode arg1, ValueNode arg2) { - return createRegionEnterNode(providers, snippetReflection, b, arg0, arg1, arg2); + return createRegionEnterNode(b, arg0, arg1, arg2); } }); r.register(new InvocationPlugin.RequiredInlineOnlyInvocationPlugin("enterSet", EnumSet.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode arg0) { - return createRegionEnterSetNode(providers, snippetReflection, b, arg0); + return createRegionEnterSetNode(b, arg0); } }); r.register(new InvocationPlugin.RequiredInlineOnlyInvocationPlugin("leave", InvocationPlugin.Receiver.class) { @@ -102,26 +100,26 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec }); } - private static boolean createRegionEnterNode(Providers providers, SnippetReflectionProvider snippetReflection, GraphBuilderContext b, ValueNode first, ValueNode... rest) { - Enum firstEnum = constValueToEnum(snippetReflection, first); - Enum[] restEnum = Arrays.stream(rest).map(n -> constValueToEnum(snippetReflection, n)).toArray(Enum[]::new); + private static boolean createRegionEnterNode(GraphBuilderContext b, ValueNode first, ValueNode... rest) { + Enum firstEnum = constValueToEnum(b, first); + Enum[] restEnum = Arrays.stream(rest).map(n -> constValueToEnum(b, n)).toArray(Enum[]::new); EnumSet features = toEnumSet(firstEnum, restEnum); b.add(new CPUFeatureRegionEnterNode(features)); - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReflection.forObject(RuntimeCPUFeatureRegion.INSTANCE), providers.getMetaAccess())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(RuntimeCPUFeatureRegion.INSTANCE), b.getMetaAccess())); return true; } - private static boolean createRegionEnterSetNode(Providers providers, SnippetReflectionProvider snippetReflection, GraphBuilderContext b, ValueNode set) { + private static boolean createRegionEnterSetNode(GraphBuilderContext b, ValueNode set) { GraalError.guarantee(set.isConstant(), "Must be a constant: %s", set); - EnumSet features = snippetReflection.asObject(EnumSet.class, set.asJavaConstant()); + EnumSet features = b.getSnippetReflection().asObject(EnumSet.class, set.asJavaConstant()); b.add(new CPUFeatureRegionEnterNode(features)); - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReflection.forObject(RuntimeCPUFeatureRegion.INSTANCE), providers.getMetaAccess())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(RuntimeCPUFeatureRegion.INSTANCE), b.getMetaAccess())); return true; } - private static Enum constValueToEnum(SnippetReflectionProvider snippetReflection, ValueNode node) { + private static Enum constValueToEnum(GraphBuilderContext b, ValueNode node) { GraalError.guarantee(node.isConstant(), "Must be a constant: %s", node); - return snippetReflection.asObject(Enum.class, node.asJavaConstant()); + return b.getSnippetReflection().asObject(Enum.class, node.asJavaConstant()); } @SuppressWarnings({"unchecked", "rawtypes"}) diff --git a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/SubstrateGraalRuntime.java b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/SubstrateGraalRuntime.java index 3522f158ccc9..fe899cc32ec6 100644 --- a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/SubstrateGraalRuntime.java +++ b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/SubstrateGraalRuntime.java @@ -24,17 +24,18 @@ */ package com.oracle.svm.graal; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; -import jdk.graal.compiler.api.runtime.GraalRuntime; -import jdk.graal.compiler.core.target.Backend; -import jdk.graal.compiler.runtime.RuntimeProvider; import org.graalvm.nativeimage.Platform; import org.graalvm.nativeimage.Platforms; import com.oracle.svm.core.graal.GraalConfiguration; +import com.oracle.svm.core.graal.meta.RuntimeConfiguration; import com.oracle.svm.core.stack.SubstrateStackIntrospection; import com.oracle.svm.util.ClassUtil; +import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import jdk.graal.compiler.api.runtime.GraalRuntime; +import jdk.graal.compiler.core.target.Backend; +import jdk.graal.compiler.runtime.RuntimeProvider; import jdk.vm.ci.code.Architecture; import jdk.vm.ci.code.stack.StackIntrospection; @@ -55,7 +56,8 @@ public T getCapability(Class clazz) { if (clazz == RuntimeProvider.class) { return (T) this; } else if (clazz == SnippetReflectionProvider.class) { - return (T) TruffleRuntimeCompilationSupport.getRuntimeConfig().getSnippetReflection(); + RuntimeConfiguration runtimeConfiguration = TruffleRuntimeCompilationSupport.getRuntimeConfig(); + return (T) runtimeConfiguration.getProviders().getSnippetReflection(); } else if (clazz == StackIntrospection.class) { return (T) SubstrateStackIntrospection.SINGLETON; } diff --git a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/runtimecompilation/RuntimeCompilationFeature.java b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/runtimecompilation/RuntimeCompilationFeature.java index 5bf2b9f3abc8..9e5caddff0d0 100644 --- a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/runtimecompilation/RuntimeCompilationFeature.java +++ b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/runtimecompilation/RuntimeCompilationFeature.java @@ -384,7 +384,8 @@ private void installRuntimeConfig(BeforeAnalysisAccessImpl config) { hostedProviders = new HostedProviders(runtimeProviders.getMetaAccess(), runtimeProviders.getCodeCache(), runtimeProviders.getConstantReflection(), runtimeProviders.getConstantFieldProvider(), runtimeProviders.getForeignCalls(), runtimeProviders.getLowerer(), runtimeProviders.getReplacements(), runtimeProviders.getStampProvider(), - runtimeConfig.getSnippetReflection(), runtimeProviders.getWordTypes(), runtimeProviders.getPlatformConfigurationProvider(), new GraphPrepareMetaAccessExtensionProvider(), + runtimeConfig.getProviders().getSnippetReflection(), runtimeProviders.getWordTypes(), runtimeProviders.getPlatformConfigurationProvider(), + new GraphPrepareMetaAccessExtensionProvider(), runtimeProviders.getLoopsDataProvider()); FeatureHandler featureHandler = config.getFeatureHandler(); @@ -398,9 +399,9 @@ private void installRuntimeConfig(BeforeAnalysisAccessImpl config) { new RuntimeCompiledMethodSupport.RuntimeCompilationGraphEncoder(ConfigurationValues.getTarget().arch, config.getUniverse().getHeapScanner())); featureHandler.forEachGraalFeature(feature -> feature.registerCodeObserver(runtimeConfig)); - Suites suites = NativeImageGenerator.createSuites(featureHandler, runtimeConfig, runtimeConfig.getSnippetReflection(), false); + Suites suites = NativeImageGenerator.createSuites(featureHandler, runtimeConfig, false); LIRSuites lirSuites = NativeImageGenerator.createLIRSuites(featureHandler, runtimeConfig.getProviders(), false); - Suites firstTierSuites = NativeImageGenerator.createFirstTierSuites(featureHandler, runtimeConfig, runtimeConfig.getSnippetReflection(), false); + Suites firstTierSuites = NativeImageGenerator.createFirstTierSuites(featureHandler, runtimeConfig, false); LIRSuites firstTierLirSuites = NativeImageGenerator.createFirstTierLIRSuites(featureHandler, runtimeConfig.getProviders(), false); TruffleRuntimeCompilationSupport.setRuntimeConfig(runtimeConfig, suites, lirSuites, firstTierSuites, firstTierLirSuites); diff --git a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/isolated/IsolatedGraalUtils.java b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/isolated/IsolatedGraalUtils.java index c21c38ef6723..1e9d5ef4e6d9 100644 --- a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/isolated/IsolatedGraalUtils.java +++ b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/isolated/IsolatedGraalUtils.java @@ -29,13 +29,6 @@ import org.graalvm.collections.EconomicMap; import org.graalvm.collections.UnmodifiableMapCursor; -import jdk.graal.compiler.code.CompilationResult; -import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.debug.DebugContext.Builder; -import jdk.graal.compiler.debug.DebugOptions; -import jdk.graal.compiler.options.OptionKey; -import jdk.graal.compiler.options.OptionsParser; -import jdk.graal.compiler.printer.GraalDebugHandlersFactory; import org.graalvm.nativeimage.CurrentIsolate; import org.graalvm.nativeimage.Isolates; import org.graalvm.nativeimage.Isolates.CreateIsolateParameters; @@ -48,15 +41,23 @@ import com.oracle.svm.core.SubstrateOptions; import com.oracle.svm.core.deopt.SubstrateInstalledCode; +import com.oracle.svm.core.graal.meta.RuntimeConfiguration; import com.oracle.svm.core.handles.PrimitiveArrayView; import com.oracle.svm.core.log.Log; import com.oracle.svm.core.option.RuntimeOptionKey; import com.oracle.svm.core.option.RuntimeOptionValues; import com.oracle.svm.core.os.MemoryProtectionProvider; -import com.oracle.svm.graal.TruffleRuntimeCompilationSupport; import com.oracle.svm.graal.SubstrateGraalUtils; +import com.oracle.svm.graal.TruffleRuntimeCompilationSupport; import com.oracle.svm.graal.meta.SubstrateMethod; +import jdk.graal.compiler.code.CompilationResult; +import jdk.graal.compiler.debug.DebugContext; +import jdk.graal.compiler.debug.DebugContext.Builder; +import jdk.graal.compiler.debug.DebugOptions; +import jdk.graal.compiler.options.OptionKey; +import jdk.graal.compiler.options.OptionsParser; +import jdk.graal.compiler.printer.GraalDebugHandlersFactory; import jdk.vm.ci.code.InstalledCode; public final class IsolatedGraalUtils { @@ -114,7 +115,8 @@ private static ClientHandle compileInNewIsolateAndInstal IsolatedCompileContext.set(new IsolatedCompileContext(clientIsolate)); SubstrateMethod method = ImageHeapObjects.deref(methodRef); - DebugContext debug = new Builder(RuntimeOptionValues.singleton(), new GraalDebugHandlersFactory(TruffleRuntimeCompilationSupport.getRuntimeConfig().getSnippetReflection())).build(); + RuntimeConfiguration runtimeConfiguration = TruffleRuntimeCompilationSupport.getRuntimeConfig(); + DebugContext debug = new Builder(RuntimeOptionValues.singleton(), new GraalDebugHandlersFactory(runtimeConfiguration.getProviders().getSnippetReflection())).build(); CompilationResult compilationResult = SubstrateGraalUtils.doCompile(debug, TruffleRuntimeCompilationSupport.getRuntimeConfig(), TruffleRuntimeCompilationSupport.getLIRSuites(), method); ClientHandle installedCodeHandle = IsolatedRuntimeCodeInstaller.installInClientIsolate( methodRef, compilationResult, IsolatedHandles.nullHandle()); @@ -132,7 +134,8 @@ public static void compileInNewIsolate(SubstrateMethod method) { Isolates.tearDownIsolate(context); IsolatedCompileClient.set(null); } else { - try (DebugContext debug = new Builder(RuntimeOptionValues.singleton(), new GraalDebugHandlersFactory(TruffleRuntimeCompilationSupport.getRuntimeConfig().getSnippetReflection())).build()) { + RuntimeConfiguration runtimeConfiguration = TruffleRuntimeCompilationSupport.getRuntimeConfig(); + try (DebugContext debug = new Builder(RuntimeOptionValues.singleton(), new GraalDebugHandlersFactory(runtimeConfiguration.getProviders().getSnippetReflection())).build()) { SubstrateGraalUtils.compile(debug, method); } } @@ -143,7 +146,8 @@ private static void compileInNewIsolate0( @SuppressWarnings("unused") @CEntryPoint.IsolateThreadContext CompilerIsolateThread isolate, ClientIsolateThread clientIsolate, ImageHeapRef methodRef) { IsolatedCompileContext.set(new IsolatedCompileContext(clientIsolate)); - try (DebugContext debug = new Builder(RuntimeOptionValues.singleton(), new GraalDebugHandlersFactory(TruffleRuntimeCompilationSupport.getRuntimeConfig().getSnippetReflection())).build()) { + RuntimeConfiguration runtimeConfiguration = TruffleRuntimeCompilationSupport.getRuntimeConfig(); + try (DebugContext debug = new Builder(RuntimeOptionValues.singleton(), new GraalDebugHandlersFactory(runtimeConfiguration.getProviders().getSnippetReflection())).build()) { SubstrateGraalUtils.doCompile(debug, TruffleRuntimeCompilationSupport.getRuntimeConfig(), TruffleRuntimeCompilationSupport.getLIRSuites(), ImageHeapObjects.deref(methodRef)); } IsolatedCompileContext.set(null); diff --git a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/meta/SubstrateRuntimeConfigurationBuilder.java b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/meta/SubstrateRuntimeConfigurationBuilder.java index 18caa7e11901..c6a0b344f6a5 100644 --- a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/meta/SubstrateRuntimeConfigurationBuilder.java +++ b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/meta/SubstrateRuntimeConfigurationBuilder.java @@ -96,9 +96,9 @@ protected LoweringProvider createLoweringProvider(ForeignCallsProvider foreignCa } @Override - protected Replacements createReplacements(Providers p, SnippetReflectionProvider reflectionProvider) { + protected Replacements createReplacements(Providers p) { BytecodeProvider bytecodeProvider = new ResolvedJavaMethodBytecodeProvider(); - return new SubstrateReplacements(p, reflectionProvider, bytecodeProvider, ConfigurationValues.getTarget(), new SubstrateGraphMakerFactory()); + return new SubstrateReplacements(p, bytecodeProvider, ConfigurationValues.getTarget(), new SubstrateGraphMakerFactory()); } @Override diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/HostedConfiguration.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/HostedConfiguration.java index b3d96c725957..940278d3e6df 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/HostedConfiguration.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/HostedConfiguration.java @@ -73,7 +73,6 @@ import com.oracle.svm.hosted.substitute.AnnotationSubstitutionProcessor; import com.oracle.svm.util.ReflectionUtil; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.CompressEncoding; import jdk.graal.compiler.core.common.spi.MetaAccessExtensionProvider; import jdk.graal.compiler.debug.DebugContext; @@ -200,10 +199,8 @@ public SVMHost createHostVM(OptionValues options, ImageClassLoader loader, Class return new SVMHost(options, loader, classInitializationSupport, annotationSubstitutions); } - public CompileQueue createCompileQueue(DebugContext debug, FeatureHandler featureHandler, HostedUniverse hostedUniverse, RuntimeConfiguration runtimeConfiguration, boolean deoptimizeAll, - SnippetReflectionProvider aSnippetReflection) { - - return new CompileQueue(debug, featureHandler, hostedUniverse, runtimeConfiguration, deoptimizeAll, aSnippetReflection); + public CompileQueue createCompileQueue(DebugContext debug, FeatureHandler featureHandler, HostedUniverse hostedUniverse, RuntimeConfiguration runtimeConfiguration, boolean deoptimizeAll) { + return new CompileQueue(debug, featureHandler, hostedUniverse, runtimeConfiguration, deoptimizeAll); } public MethodTypeFlowBuilder createMethodTypeFlowBuilder(PointsToAnalysis bb, PointsToAnalysisMethod method, MethodFlowsGraph flowsGraph, MethodFlowsGraph.GraphKind graphKind) { diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java index bd3560a9f4c7..b04e6214a7e2 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java @@ -644,7 +644,7 @@ protected void doRun(Map entryPoints, JavaMainSupport j NativeImageCodeCache codeCache; CompileQueue compileQueue; try (StopTimer t = TimerCollection.createTimerAndStart(TimerCollection.Registry.COMPILE_TOTAL)) { - compileQueue = HostedConfiguration.instance().createCompileQueue(debug, featureHandler, hUniverse, runtimeConfiguration, DeoptTester.enabled(), bb.getSnippetReflectionProvider()); + compileQueue = HostedConfiguration.instance().createCompileQueue(debug, featureHandler, hUniverse, runtimeConfiguration, DeoptTester.enabled()); if (ImageSingletons.contains(RuntimeCompilationCallbacks.class)) { ImageSingletons.lookup(RuntimeCompilationCallbacks.class).onCompileQueueCreation(bb, hUniverse, compileQueue); } @@ -1189,7 +1189,7 @@ private static HostedProviders createHostedProviders(TargetDescription target, A aWordTypes, platformConfig, aMetaAccessExtensionProvider, originalProviders.getLoopsDataProvider()); BytecodeProvider bytecodeProvider = new ResolvedJavaMethodBytecodeProvider(); - SubstrateReplacements aReplacements = new SubstrateReplacements(aProviders, aSnippetReflection, bytecodeProvider, target, new SubstrateGraphMakerFactory()); + SubstrateReplacements aReplacements = new SubstrateReplacements(aProviders, bytecodeProvider, target, new SubstrateGraphMakerFactory()); aProviders = (HostedProviders) aReplacements.getProviders(); assert aReplacements == aProviders.getReplacements(); @@ -1378,7 +1378,7 @@ public static void registerGraphBuilderPlugins(FeatureHandler featureHandler, Ru plugins.appendNodePlugin(new InjectedAccessorsPlugin()); plugins.appendNodePlugin(new EarlyConstantFoldLoadFieldPlugin(providers.getMetaAccess())); plugins.appendNodePlugin(new ConstantFoldLoadFieldPlugin(reason)); - plugins.appendNodePlugin(new CInterfaceInvocationPlugin(providers.getMetaAccess(), hostedSnippetReflection, nativeLibs)); + plugins.appendNodePlugin(new CInterfaceInvocationPlugin(providers.getMetaAccess(), nativeLibs)); plugins.appendNodePlugin(new LocalizationFeature.CharsetNodePlugin()); plugins.appendInlineInvokePlugin(wordOperationPlugin); @@ -1433,14 +1433,13 @@ public T getInjectedArgument(Class type) { SubstrateGraphBuilderPlugins.registerInvocationPlugins(annotationSubstitutionProcessor, loader, - hostedSnippetReflection, plugins.getInvocationPlugins(), replacements, reason, architecture, supportsStubBasedPlugins); - featureHandler.forEachGraalFeature(feature -> feature.registerInvocationPlugins(providers, hostedSnippetReflection, plugins, reason)); + featureHandler.forEachGraalFeature(feature -> feature.registerInvocationPlugins(providers, plugins, reason)); providers.setGraphBuilderPlugins(plugins); replacements.setGraphBuilderPlugins(plugins); @@ -1503,7 +1502,7 @@ private static boolean checkInvocationPluginMethods(SubstrateReplacements replac return true; } - public static Suites createSuites(FeatureHandler featureHandler, RuntimeConfiguration runtimeConfig, SnippetReflectionProvider snippetReflection, boolean hosted) { + public static Suites createSuites(FeatureHandler featureHandler, RuntimeConfiguration runtimeConfig, boolean hosted) { SubstrateBackend backend = runtimeConfig.getBackendForNormalMethod(); Suites suites; if (hosted) { @@ -1511,10 +1510,10 @@ public static Suites createSuites(FeatureHandler featureHandler, RuntimeConfigur } else { suites = GraalConfiguration.runtimeInstance().createSuites(RuntimeOptionValues.singleton(), hosted, ConfigurationValues.getTarget().arch); } - return modifySuites(backend, suites, featureHandler, runtimeConfig, snippetReflection, hosted, false); + return modifySuites(backend, suites, featureHandler, runtimeConfig, hosted, false); } - public static Suites createFirstTierSuites(FeatureHandler featureHandler, RuntimeConfiguration runtimeConfig, SnippetReflectionProvider snippetReflection, boolean hosted) { + public static Suites createFirstTierSuites(FeatureHandler featureHandler, RuntimeConfiguration runtimeConfig, boolean hosted) { SubstrateBackend backend = runtimeConfig.getBackendForNormalMethod(); Suites suites; if (hosted) { @@ -1522,12 +1521,11 @@ public static Suites createFirstTierSuites(FeatureHandler featureHandler, Runtim } else { suites = GraalConfiguration.runtimeInstance().createFirstTierSuites(RuntimeOptionValues.singleton(), hosted, ConfigurationValues.getTarget().arch); } - return modifySuites(backend, suites, featureHandler, runtimeConfig, snippetReflection, hosted, true); + return modifySuites(backend, suites, featureHandler, hosted, true); } - @SuppressWarnings("unused") - private static Suites modifySuites(SubstrateBackend backend, Suites suites, FeatureHandler featureHandler, RuntimeConfiguration runtimeConfig, - SnippetReflectionProvider snippetReflection, boolean hosted, boolean firstTier) { + private static Suites modifySuites(SubstrateBackend backend, Suites suites, FeatureHandler featureHandler, + boolean hosted, boolean firstTier) { Providers runtimeCallProviders = backend.getProviders(); PhaseSuite highTier = suites.getHighTier(); @@ -1594,7 +1592,7 @@ private static Suites modifySuites(SubstrateBackend backend, Suites suites, Feat } } - featureHandler.forEachGraalFeature(feature -> feature.registerGraalPhases(runtimeCallProviders, snippetReflection, suites, hosted)); + featureHandler.forEachGraalFeature(feature -> feature.registerGraalPhases(runtimeCallProviders, suites, hosted)); if (hosted && ImageBuildStatistics.Options.CollectImageBuildStatistics.getValue(HostedOptionValues.singleton())) { highTier.prependPhase(new ImageBuildStatisticsCounterPhase(ImageBuildStatistics.CheckCountLocation.BEFORE_HIGH_TIER)); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ResourcesFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ResourcesFeature.java index d3411c5847d2..ce6bb7599d9b 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ResourcesFeature.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ResourcesFeature.java @@ -93,7 +93,6 @@ import com.oracle.svm.util.ModuleSupport; import com.oracle.svm.util.ReflectionUtil; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; @@ -622,7 +621,7 @@ public void beforeCompilation(BeforeCompilationAccess access) { } @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) { if (!reason.duringAnalysis() || reason == ParsingReason.JITCompilation) { return; } @@ -634,11 +633,11 @@ public void registerInvocationPlugins(Providers providers, SnippetReflectionProv Method resolveResourceName = ReflectionUtil.lookupMethod(Class.class, "resolveName", String.class); for (Method method : resourceMethods) { - registerResourceRegistrationPlugin(plugins.getInvocationPlugins(), method, snippetReflection, resolveResourceName, reason); + registerResourceRegistrationPlugin(plugins.getInvocationPlugins(), method, providers, resolveResourceName, reason); } } - private void registerResourceRegistrationPlugin(InvocationPlugins plugins, Method method, SnippetReflectionProvider snippetReflectionProvider, Method resolveResourceName, ParsingReason reason) { + private void registerResourceRegistrationPlugin(InvocationPlugins plugins, Method method, Providers providers, Method resolveResourceName, ParsingReason reason) { List> parameterTypes = new ArrayList<>(); assert !Modifier.isStatic(method.getModifiers()); parameterTypes.add(InvocationPlugin.Receiver.class); @@ -654,8 +653,8 @@ public boolean isDecorator() { public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode arg) { try { if (!sealed && receiver.isConstant() && arg.isJavaConstant() && !arg.isNullConstant()) { - Class clazz = snippetReflectionProvider.asObject(Class.class, receiver.get().asJavaConstant()); - String resource = snippetReflectionProvider.asObject(String.class, arg.asJavaConstant()); + Class clazz = providers.getSnippetReflection().asObject(Class.class, receiver.get().asJavaConstant()); + String resource = providers.getSnippetReflection().asObject(String.class, arg.asJavaConstant()); String resourceName = (String) resolveResourceName.invoke(clazz, resource); b.add(ReachabilityRegistrationNode.create(() -> RuntimeResourceAccess.addResource(clazz.getModule(), resourceName), reason)); return true; diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/CGlobalDataFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/CGlobalDataFeature.java index 741315a0a6dd..686aa3a37b72 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/CGlobalDataFeature.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/CGlobalDataFeature.java @@ -36,7 +36,23 @@ import java.util.stream.Collectors; import java.util.stream.IntStream; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import org.graalvm.nativeimage.ImageSingletons; + +import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.svm.core.ParsingReason; +import com.oracle.svm.core.c.CGlobalData; +import com.oracle.svm.core.c.CGlobalDataImpl; +import com.oracle.svm.core.c.CGlobalDataNonConstantRegistry; +import com.oracle.svm.core.config.ConfigurationValues; +import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; +import com.oracle.svm.core.feature.InternalFeature; +import com.oracle.svm.core.graal.code.CGlobalDataInfo; +import com.oracle.svm.core.graal.nodes.CGlobalDataLoadAddressNode; +import com.oracle.svm.core.util.VMError; +import com.oracle.svm.hosted.image.RelocatableBuffer; +import com.oracle.svm.hosted.meta.HostedSnippetReflectionProvider; +import com.oracle.svm.util.ReflectionUtil; + import jdk.graal.compiler.core.common.memory.BarrierType; import jdk.graal.compiler.core.common.memory.MemoryOrderMode; import jdk.graal.compiler.core.common.type.IntegerStamp; @@ -67,23 +83,6 @@ import jdk.graal.compiler.nodes.memory.ReadNode; import jdk.graal.compiler.nodes.memory.address.OffsetAddressNode; import jdk.graal.compiler.phases.util.Providers; -import org.graalvm.nativeimage.ImageSingletons; - -import com.oracle.graal.pointsto.meta.AnalysisType; -import com.oracle.svm.core.ParsingReason; -import com.oracle.svm.core.c.CGlobalData; -import com.oracle.svm.core.c.CGlobalDataImpl; -import com.oracle.svm.core.c.CGlobalDataNonConstantRegistry; -import com.oracle.svm.core.config.ConfigurationValues; -import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature; -import com.oracle.svm.core.feature.InternalFeature; -import com.oracle.svm.core.graal.code.CGlobalDataInfo; -import com.oracle.svm.core.graal.nodes.CGlobalDataLoadAddressNode; -import com.oracle.svm.core.util.VMError; -import com.oracle.svm.hosted.image.RelocatableBuffer; -import com.oracle.svm.hosted.meta.HostedSnippetReflectionProvider; -import com.oracle.svm.util.ReflectionUtil; - import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -121,16 +120,16 @@ public void afterHeapLayout(AfterHeapLayoutAccess access) { } @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { Registration r = new Registration(plugins.getInvocationPlugins(), CGlobalData.class); r.register(new RequiredInvocationPlugin("get", Receiver.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { - assert snippetReflection instanceof HostedSnippetReflectionProvider; - JavaConstant nonConstantRegistryJavaConstant = snippetReflection.forObject(nonConstantRegistry); + assert providers.getSnippetReflection() instanceof HostedSnippetReflectionProvider; + JavaConstant nonConstantRegistryJavaConstant = providers.getSnippetReflection().forObject(nonConstantRegistry); ValueNode cGlobalDataNode = receiver.get(); if (cGlobalDataNode.isConstant()) { - CGlobalDataImpl data = snippetReflection.asObject(CGlobalDataImpl.class, cGlobalDataNode.asJavaConstant()); + CGlobalDataImpl data = providers.getSnippetReflection().asObject(CGlobalDataImpl.class, cGlobalDataNode.asJavaConstant()); CGlobalDataInfo info = CGlobalDataFeature.this.map.get(data); b.addPush(targetMethod.getSignature().getReturnKind(), new CGlobalDataLoadAddressNode(info)); } else { diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/function/CEntryPointSupport.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/function/CEntryPointSupport.java index f22d26bf26e1..9c0fc6ae7071 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/function/CEntryPointSupport.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/function/CEntryPointSupport.java @@ -45,7 +45,6 @@ import com.oracle.svm.core.graal.nodes.LoweredDeadEndNode; import com.oracle.svm.core.graal.nodes.ReadReservedRegister; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.nodes.AbstractBeginNode; import jdk.graal.compiler.nodes.ConstantNode; import jdk.graal.compiler.nodes.IfNode; @@ -65,7 +64,7 @@ @AutomaticallyRegisteredFeature public class CEntryPointSupport implements InternalFeature { @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { registerEntryPointActionsPlugins(plugins.getInvocationPlugins()); registerCurrentIsolatePlugins(plugins.getInvocationPlugins()); } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java index 2cea176fbfc5..2c41f1f186da 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java @@ -80,7 +80,7 @@ public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, Hos AnalysisType returnType = method.getSignature().getReturnType(); ValueNode arg = kit.getInitialArguments().get(0); - CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess()); JavaKind pushKind = CInterfaceInvocationPlugin.pushKind(method); ValueNode returnValue; diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/EarlyClassInitializerAnalysis.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/EarlyClassInitializerAnalysis.java index a7e0fa1687a9..fc8dc951f1f4 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/EarlyClassInitializerAnalysis.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/EarlyClassInitializerAnalysis.java @@ -31,6 +31,22 @@ import java.util.Set; import java.util.function.Supplier; +import org.graalvm.nativeimage.ImageSingletons; +import org.graalvm.nativeimage.impl.RuntimeClassInitializationSupport; + +import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider; +import com.oracle.graal.pointsto.phases.NoClassInitializationPlugin; +import com.oracle.graal.pointsto.util.GraalAccess; +import com.oracle.svm.core.ParsingReason; +import com.oracle.svm.core.classinitialization.EnsureClassInitializedNode; +import com.oracle.svm.core.graal.thread.VMThreadLocalAccess; +import com.oracle.svm.core.option.HostedOptionValues; +import com.oracle.svm.core.util.VMError; +import com.oracle.svm.hosted.FallbackFeature; +import com.oracle.svm.hosted.phases.EarlyConstantFoldLoadFieldPlugin; +import com.oracle.svm.hosted.snippets.ReflectionPlugins; +import com.oracle.svm.hosted.snippets.SubstrateGraphBuilderPlugins; + import jdk.graal.compiler.core.common.GraalBailoutException; import jdk.graal.compiler.debug.DebugContext; import jdk.graal.compiler.debug.DebugContext.Builder; @@ -58,22 +74,6 @@ import jdk.graal.compiler.phases.OptimisticOptimizations; import jdk.graal.compiler.phases.tiers.HighTierContext; import jdk.graal.compiler.phases.util.Providers; -import org.graalvm.nativeimage.ImageSingletons; -import org.graalvm.nativeimage.impl.RuntimeClassInitializationSupport; - -import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider; -import com.oracle.graal.pointsto.phases.NoClassInitializationPlugin; -import com.oracle.graal.pointsto.util.GraalAccess; -import com.oracle.svm.core.ParsingReason; -import com.oracle.svm.core.classinitialization.EnsureClassInitializedNode; -import com.oracle.svm.core.graal.thread.VMThreadLocalAccess; -import com.oracle.svm.core.option.HostedOptionValues; -import com.oracle.svm.core.util.VMError; -import com.oracle.svm.hosted.FallbackFeature; -import com.oracle.svm.hosted.phases.EarlyConstantFoldLoadFieldPlugin; -import com.oracle.svm.hosted.snippets.ReflectionPlugins; -import com.oracle.svm.hosted.snippets.SubstrateGraphBuilderPlugins; - import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.ResolvedJavaField; import jdk.vm.ci.meta.ResolvedJavaMethod; @@ -174,9 +174,9 @@ private boolean canInitializeWithoutSideEffects(ResolvedJavaMethod clinit, Set adaptSignatureAndConvertArguments(Nati ElementInfo typeInfo = nativeLibraries.findElementInfo(parameterTypes[i]); if (typeInfo instanceof EnumInfo) { ValueNode argumentValue = kit.maybeCreateExplicitNullCheck(arguments.get(i)); - CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess()); argumentValue = tool.createEnumValueInvoke(kit, (EnumInfo) typeInfo, cEnumKind, argumentValue); arguments.set(i, argumentValue); @@ -129,7 +129,7 @@ private ValueNode adaptReturnValue(AnalysisMethod method, NativeLibraries native // We take a word return type because checks expect word type replacements, but it is // narrowed to cEnumKind here. - CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess()); returnValue = tool.createEnumLookupInvoke(kit, declaredReturnType, (EnumInfo) typeInfo, cEnumKind, returnValue); } else { throw UserError.abort("Return types of methods annotated with @%s are restricted to primitive types, word types and enumerations (@%s): %s", diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java index 71065a6d71a5..3f378f124fb5 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java @@ -351,7 +351,7 @@ private static void adaptArgumentValues(HostedGraphKit kit, List p // These methods must be called after the prologue established a safe context for (int i = 0; i < parameterEnumInfos.length; i++) { if (parameterEnumInfos[i] != null) { - CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess()); args[i] = tool.createEnumLookupInvoke(kit, parameterTypes.get(i), parameterEnumInfos[i], cEnumParameterKind, args[i]); } } @@ -558,7 +558,7 @@ private ValueNode adaptReturnValue(HostedGraphKit kit, ValueNode value) { // Always return enum values as a signed word because it should never be a problem if // the caller expects a narrower integer type and the various checks already handle // replacements with word types. - CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess()); JavaKind cEnumReturnType = kit.getWordTypes().getWordKind(); assert !cEnumReturnType.isUnsigned() : "requires correct representation of signed values"; returnValue = tool.startEnumValueInvokeWithException(kit, (EnumInfo) typeInfo, cEnumReturnType, returnValue); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java index 3f7628962290..c77f7fd3576e 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java @@ -77,7 +77,6 @@ import com.oracle.svm.util.ImageBuildStatistics; import jdk.graal.compiler.api.replacements.Fold; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.asm.Assembler; import jdk.graal.compiler.bytecode.BytecodeProvider; import jdk.graal.compiler.code.CompilationResult; @@ -175,7 +174,6 @@ protected PhaseSuite getAfterParseSuite() { private LIRSuites deoptTargetLIRSuites = null; private final ConcurrentMap dataCache; - protected SnippetReflectionProvider snippetReflection; protected final FeatureHandler featureHandler; protected final GlobalMetrics metricValues = new GlobalMetrics(); private final AnalysisToHostedGraphTransplanter graphTransplanter; @@ -349,8 +347,7 @@ public Description getDescription() { } @SuppressWarnings("this-escape") - public CompileQueue(DebugContext debug, FeatureHandler featureHandler, HostedUniverse universe, RuntimeConfiguration runtimeConfiguration, Boolean deoptimizeAll, - SnippetReflectionProvider snippetReflection) { + public CompileQueue(DebugContext debug, FeatureHandler featureHandler, HostedUniverse universe, RuntimeConfiguration runtimeConfiguration, Boolean deoptimizeAll) { this.universe = universe; this.compilations = new ConcurrentHashMap<>(); this.runtimeConfig = runtimeConfiguration; @@ -359,7 +356,6 @@ public CompileQueue(DebugContext debug, FeatureHandler featureHandler, HostedUni this.dataCache = new ConcurrentHashMap<>(); this.executor = new CompletionExecutor(debug, universe.getBigBang()); this.featureHandler = featureHandler; - this.snippetReflection = snippetReflection; this.graphTransplanter = createGraphTransplanter(); this.defaultParseHooks = new ParseHooks(this); @@ -456,11 +452,11 @@ protected void createSuites() { } protected Suites createRegularSuites() { - return NativeImageGenerator.createSuites(featureHandler, runtimeConfig, snippetReflection, true); + return NativeImageGenerator.createSuites(featureHandler, runtimeConfig, true); } protected Suites createDeoptTargetSuites() { - return NativeImageGenerator.createSuites(featureHandler, runtimeConfig, snippetReflection, true); + return NativeImageGenerator.createSuites(featureHandler, runtimeConfig, true); } protected LIRSuites createLIRSuites() { diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedReplacements.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedReplacements.java index 7ffd8a9454b3..502a3a50e429 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedReplacements.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedReplacements.java @@ -32,7 +32,6 @@ import com.oracle.svm.hosted.meta.HostedMethod; import com.oracle.svm.hosted.meta.HostedUniverse; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.bytecode.BytecodeProvider; import jdk.graal.compiler.java.BytecodeParser; import jdk.graal.compiler.nodes.GraphEncoder; @@ -64,9 +63,9 @@ public class HostedReplacements extends SubstrateReplacements { private final HostedUniverse hUniverse; private final SubstrateReplacements aReplacements; - public HostedReplacements(HostedUniverse hUniverse, Providers providers, SnippetReflectionProvider snippetReflection, TargetDescription target, HostedProviders anaylysisProviders, + public HostedReplacements(HostedUniverse hUniverse, Providers providers, TargetDescription target, HostedProviders anaylysisProviders, BytecodeProvider bytecodeProvider) { - super(providers, snippetReflection, bytecodeProvider, target, null); + super(providers, bytecodeProvider, target, null); this.hUniverse = hUniverse; this.aReplacements = (SubstrateReplacements) anaylysisProviders.getReplacements(); } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedRuntimeConfigurationBuilder.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedRuntimeConfigurationBuilder.java index 3001707c40ee..ba90bd1cb4ea 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedRuntimeConfigurationBuilder.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/HostedRuntimeConfigurationBuilder.java @@ -91,9 +91,9 @@ protected LoweringProvider createLoweringProvider(ForeignCallsProvider foreignCa } @Override - protected Replacements createReplacements(Providers p, SnippetReflectionProvider reflectionProvider) { + protected Replacements createReplacements(Providers p) { BytecodeProvider bytecodeProvider = new ResolvedJavaMethodBytecodeProvider(); - return new HostedReplacements(universe, p, reflectionProvider, ConfigurationValues.getTarget(), analysisProviders, bytecodeProvider); + return new HostedReplacements(universe, p, ConfigurationValues.getTarget(), analysisProviders, bytecodeProvider); } @Override diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SharedRuntimeConfigurationBuilder.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SharedRuntimeConfigurationBuilder.java index 3aa829140df4..a902028ea059 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SharedRuntimeConfigurationBuilder.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SharedRuntimeConfigurationBuilder.java @@ -125,7 +125,7 @@ public final RuntimeConfiguration build() { * Use the snippet reflection provider during image building replacement. It will be * replaced by the GraalGraphObjectReplacer for run time compilation. */ - Replacements replacements = createReplacements(p, snippetReflection); + Replacements replacements = createReplacements(p); p = (Providers) replacements.getProviders(); EnumMap backends = new EnumMap<>(ConfigKind.class); @@ -146,7 +146,7 @@ public final RuntimeConfiguration build() { } } - return new RuntimeConfiguration(p, snippetReflection, backends, handlers); + return new RuntimeConfiguration(p, backends, handlers); } protected abstract Providers createProviders(CodeCacheProvider codeCache, ConstantReflectionProvider constantReflection, ConstantFieldProvider constantFieldProvider, @@ -168,7 +168,7 @@ private StampProvider createStampProvider() { protected abstract LoweringProvider createLoweringProvider(ForeignCallsProvider foreignCalls, MetaAccessExtensionProvider metaAccessExtensionProvider); - protected abstract Replacements createReplacements(Providers p, SnippetReflectionProvider reflectionProvider); + protected abstract Replacements createReplacements(Providers p); protected abstract CodeCacheProvider createCodeCacheProvider(RegisterConfig registerConfig); } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java index b62dea3abe53..a34798c9e094 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java @@ -33,7 +33,6 @@ import com.oracle.svm.core.util.VMError; import com.oracle.svm.hosted.c.info.EnumInfo; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.type.ObjectStamp; import jdk.graal.compiler.core.common.type.StampFactory; import jdk.graal.compiler.core.common.type.StampPair; @@ -65,13 +64,11 @@ static CallTargetFactory from(HostedGraphKit kit) { } } - private final SnippetReflectionProvider snippetReflection; private final AnalysisMethod convertJavaToCLongMethod; private final AnalysisMethod convertJavaToCIntMethod; private final AnalysisMethod convertCToJavaMethod; - public CInterfaceEnumTool(AnalysisMetaAccess metaAccess, SnippetReflectionProvider snippetReflection) { - this.snippetReflection = snippetReflection; + public CInterfaceEnumTool(AnalysisMetaAccess metaAccess) { try { convertJavaToCLongMethod = metaAccess.lookupJavaMethod(EnumRuntimeData.class.getDeclaredMethod("convertJavaToCLong", Enum.class)); convertJavaToCIntMethod = metaAccess.lookupJavaMethod(EnumRuntimeData.class.getDeclaredMethod("convertJavaToCInt", Enum.class)); @@ -101,7 +98,7 @@ private MethodCallTargetNode invokeEnumValue(GraphBuilderTool b, CallTargetFacto AnalysisMethod valueMethod = getValueMethodForKind(resultKind); AnalysisType returnType = valueMethod.getSignature().getReturnType(); ValueNode[] args = new ValueNode[2]; - args[0] = ConstantNode.forConstant(snippetReflection.forObject(enumInfo.getRuntimeData()), b.getMetaAccess(), b.getGraph()); + args[0] = ConstantNode.forConstant(b.getSnippetReflection().forObject(enumInfo.getRuntimeData()), b.getMetaAccess(), b.getGraph()); args[1] = arg; StampPair returnStamp = StampFactory.forDeclaredType(null, returnType, false); @@ -126,7 +123,7 @@ public ValueNode createEnumLookupInvoke(HostedGraphKit kit, AnalysisType enumTyp private MethodCallTargetNode invokeEnumLookup(GraphBuilderTool b, CallTargetFactory callTargetFactory, int bci, EnumInfo enumInfo, JavaKind parameterKind, ValueNode arg) { ValueNode[] args = new ValueNode[2]; - args[0] = ConstantNode.forConstant(snippetReflection.forObject(enumInfo.getRuntimeData()), b.getMetaAccess(), b.getGraph()); + args[0] = ConstantNode.forConstant(b.getSnippetReflection().forObject(enumInfo.getRuntimeData()), b.getMetaAccess(), b.getGraph()); assert !Modifier.isStatic(convertCToJavaMethod.getModifiers()) && convertCToJavaMethod.getSignature().getParameterCount(false) == 1; JavaKind expectedKind = convertCToJavaMethod.getSignature().getParameterType(0).getJavaKind(); args[1] = CInterfaceInvocationPlugin.adaptPrimitiveType(b.getGraph(), arg, parameterKind, expectedKind, false); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java index d9a40b1887d6..08ef448fec0e 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java @@ -58,7 +58,6 @@ import com.oracle.svm.hosted.code.CEntryPointJavaCallStubMethod; import com.oracle.svm.hosted.code.CFunctionPointerCallStubSupport; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.calc.FloatConvert; import jdk.graal.compiler.core.common.memory.BarrierType; import jdk.graal.compiler.core.common.memory.MemoryOrderMode; @@ -101,12 +100,10 @@ public class CInterfaceInvocationPlugin implements NodePlugin { private final NativeLibraries nativeLibs; private final ResolvedJavaType functionPointerType; - private final SnippetReflectionProvider snippetReflection; - public CInterfaceInvocationPlugin(MetaAccessProvider metaAccess, SnippetReflectionProvider snippetReflection, NativeLibraries nativeLibs) { + public CInterfaceInvocationPlugin(MetaAccessProvider metaAccess, NativeLibraries nativeLibs) { this.nativeLibs = nativeLibs; this.functionPointerType = metaAccess.lookupJavaType(CFunctionPointer.class); - this.snippetReflection = snippetReflection; } @Override @@ -158,7 +155,7 @@ private static boolean replaceOffsetOf(GraphBuilderContext b, AnalysisMethod met return true; } - private boolean replaceAccessor(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, AccessorInfo accessorInfo, int displacement) { + private static boolean replaceAccessor(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, AccessorInfo accessorInfo, int displacement) { StructuredGraph graph = b.getGraph(); SizableInfo sizableInfo = (SizableInfo) accessorInfo.getParent(); int elementSize = sizableInfo.getSizeInfo().getProperty(); @@ -185,7 +182,7 @@ private boolean replaceAccessor(GraphBuilderContext b, AnalysisMethod method, Va readKind = resultKind; } AddressNode offsetAddress = makeOffsetAddress(graph, args, accessorInfo, base, displacement, elementSize); - LocationIdentity locationIdentity = makeLocationIdentity(b, snippetReflection, method, args, accessorInfo); + LocationIdentity locationIdentity = makeLocationIdentity(b, method, args, accessorInfo); final Stamp stamp; if (readKind == JavaKind.Object) { stamp = b.getInvokeReturnStamp(null).getTrustedStamp(); @@ -209,7 +206,7 @@ private boolean replaceAccessor(GraphBuilderContext b, AnalysisMethod method, Va JavaKind valueKind = value.getStackKind(); JavaKind writeKind = kindFromSize(elementSize, valueKind); AddressNode offsetAddress = makeOffsetAddress(graph, args, accessorInfo, base, displacement, elementSize); - LocationIdentity locationIdentity = makeLocationIdentity(b, snippetReflection, method, args, accessorInfo); + LocationIdentity locationIdentity = makeLocationIdentity(b, method, args, accessorInfo); if (isPinnedObject) { b.add(new JavaWriteNode(writeKind, offsetAddress, locationIdentity, value, BarrierType.NONE, true)); } else { @@ -223,7 +220,7 @@ private boolean replaceAccessor(GraphBuilderContext b, AnalysisMethod method, Va } } - private boolean replaceBitfieldAccessor(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, StructBitfieldInfo bitfieldInfo, AccessorInfo accessorInfo) { + private static boolean replaceBitfieldAccessor(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, StructBitfieldInfo bitfieldInfo, AccessorInfo accessorInfo) { int byteOffset = bitfieldInfo.getByteOffsetInfo().getProperty(); int startBit = bitfieldInfo.getStartBitInfo().getProperty(); int endBit = bitfieldInfo.getEndBitInfo().getProperty(); @@ -284,7 +281,7 @@ private boolean replaceBitfieldAccessor(GraphBuilderContext b, AnalysisMethod me * bits around the written bitfield unchanged. */ AddressNode address = makeOffsetAddress(graph, args, accessorInfo, base, byteOffset, -1); - LocationIdentity locationIdentity = makeLocationIdentity(b, snippetReflection, method, args, accessorInfo); + LocationIdentity locationIdentity = makeLocationIdentity(b, method, args, accessorInfo); Stamp stamp = IntegerStamp.create(memoryKind.getBitCount()); ValueNode cur = readPrimitive(b, address, locationIdentity, stamp, accessorInfo); cur = adaptPrimitiveType(graph, cur, memoryKind, computeKind, true); @@ -380,7 +377,7 @@ private static AddressNode makeOffsetAddress(StructuredGraph graph, ValueNode[] return graph.addOrUniqueWithInputs(new OffsetAddressNode(base, makeOffset(graph, args, accessorInfo, displacement, indexScaling))); } - private static LocationIdentity makeLocationIdentity(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, AnalysisMethod method, ValueNode[] args, AccessorInfo accessorInfo) { + private static LocationIdentity makeLocationIdentity(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, AccessorInfo accessorInfo) { LocationIdentity locationIdentity; if (accessorInfo.hasLocationIdentityParameter()) { ValueNode locationIdentityNode = args[accessorInfo.locationIdentityParameterNumber(true)]; @@ -389,7 +386,7 @@ private static LocationIdentity makeLocationIdentity(GraphBuilderContext b, Snip "locationIdentity is not a compile time constant for call to " + method.format("%H.%n(%p)") + " in " + b.getMethod().asStackTraceElement(b.bci()), method).getMessage()); } - locationIdentity = snippetReflection.asObject(LocationIdentity.class, locationIdentityNode.asJavaConstant()); + locationIdentity = b.getSnippetReflection().asObject(LocationIdentity.class, locationIdentityNode.asJavaConstant()); } else if (accessorInfo.hasUniqueLocationIdentity()) { StructFieldInfo fieldInfo = (StructFieldInfo) accessorInfo.getParent(); assert fieldInfo.getLocationIdentity() != null; @@ -462,7 +459,7 @@ private static JavaKind kindFromSize(int sizeInBytes, JavaKind matchingKind) { throw shouldNotReachHere("Unsupported size: " + sizeInBytes); } - private boolean replaceConstant(GraphBuilderContext b, AnalysisMethod method, ConstantInfo constantInfo) { + private static boolean replaceConstant(GraphBuilderContext b, AnalysisMethod method, ConstantInfo constantInfo) { Object value = constantInfo.getValueInfo().getProperty(); JavaKind kind = b.getWordTypes().asKind(b.getInvokeReturnType()); @@ -481,7 +478,7 @@ private boolean replaceConstant(GraphBuilderContext b, AnalysisMethod method, Co break; case STRING: case BYTEARRAY: - valueNode = ConstantNode.forConstant(snippetReflection.forObject(value), b.getMetaAccess(), b.getGraph()); + valueNode = ConstantNode.forConstant(b.getSnippetReflection().forObject(value), b.getMetaAccess(), b.getGraph()); break; default: throw shouldNotReachHere("Unexpected constant kind " + constantInfo); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/EnumSwitchPlugin.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/EnumSwitchPlugin.java index 1a0df5e4a9ff..7d8110e94c27 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/EnumSwitchPlugin.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/EnumSwitchPlugin.java @@ -40,7 +40,6 @@ import com.oracle.svm.hosted.FeatureImpl.DuringSetupAccessImpl; import com.oracle.svm.util.ReflectionUtil; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.debug.GraalError; import jdk.graal.compiler.nodes.ConstantNode; import jdk.graal.compiler.nodes.StructuredGraph; @@ -64,11 +63,9 @@ final class EnumSwitchPlugin implements NodePlugin { private static final String METHOD_NAME_PREFIX = "$SWITCH_TABLE$"; - private final SnippetReflectionProvider snippetReflection; private final ParsingReason reason; - EnumSwitchPlugin(SnippetReflectionProvider snippetReflection, ParsingReason reason) { - this.snippetReflection = snippetReflection; + EnumSwitchPlugin(ParsingReason reason) { this.reason = reason; } @@ -113,7 +110,7 @@ public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod m, ValueNo } if (switchTable instanceof int[]) { - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReflection.forObject(switchTable), 1, true, b.getMetaAccess())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(switchTable), 1, true, b.getMetaAccess())); return true; } return false; @@ -148,6 +145,6 @@ public void afterAnalysis(AfterAnalysisAccess access) { @Override public void registerGraphBuilderPlugins(Providers providers, Plugins plugins, ParsingReason reason) { - plugins.appendNodePlugin(new EnumSwitchPlugin(providers.getSnippetReflection(), reason)); + plugins.appendNodePlugin(new EnumSwitchPlugin(reason)); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/SubstrateClassInitializationPlugin.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/SubstrateClassInitializationPlugin.java index b515f15b3835..bc4dcd1fe2ea 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/SubstrateClassInitializationPlugin.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/SubstrateClassInitializationPlugin.java @@ -26,16 +26,14 @@ import java.util.function.Supplier; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; +import com.oracle.svm.core.classinitialization.EnsureClassInitializedNode; +import com.oracle.svm.hosted.SVMHost; + import jdk.graal.compiler.nodes.ConstantNode; import jdk.graal.compiler.nodes.FrameState; import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.graphbuilderconf.ClassInitializationPlugin; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; - -import com.oracle.svm.core.classinitialization.EnsureClassInitializedNode; -import com.oracle.svm.hosted.SVMHost; - import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.ResolvedJavaType; @@ -61,8 +59,7 @@ public void loadReferencedType(GraphBuilderContext builder, ConstantPool constan @Override public boolean apply(GraphBuilderContext builder, ResolvedJavaType type, Supplier frameState) { if (EnsureClassInitializedNode.needsRuntimeInitialization(builder.getMethod().getDeclaringClass(), type)) { - SnippetReflectionProvider snippetReflection = builder.getSnippetReflection(); - emitEnsureClassInitialized(builder, snippetReflection.forObject(host.dynamicHub(type)), frameState.get()); + emitEnsureClassInitialized(builder, builder.getSnippetReflection().forObject(host.dynamicHub(type)), frameState.get()); return true; } return false; diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionFeature.java index 2277fd9418c1..fb754f9907f6 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionFeature.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionFeature.java @@ -84,7 +84,6 @@ import com.oracle.svm.util.ModuleSupport; import com.oracle.svm.util.ReflectionUtil; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; import jdk.graal.compiler.phases.util.Providers; import jdk.internal.reflect.CallerSensitive; @@ -364,9 +363,9 @@ public String getDeletionReason(Field reflectionField) { } @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { FallbackFeature fallbackFeature = ImageSingletons.contains(FallbackFeature.class) ? ImageSingletons.lookup(FallbackFeature.class) : null; - ReflectionPlugins.registerInvocationPlugins(loader, snippetReflection, annotationSubstitutions, + ReflectionPlugins.registerInvocationPlugins(loader, annotationSubstitutions, plugins.getClassInitializationPlugin(), plugins.getInvocationPlugins(), aUniverse, reason, fallbackFeature); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/ReflectionPlugins.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/ReflectionPlugins.java index 5c9a9f5edecd..b6ed52e87d5d 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/ReflectionPlugins.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/ReflectionPlugins.java @@ -72,7 +72,6 @@ import com.oracle.svm.util.ModuleSupport; import com.oracle.svm.util.ReflectionUtil; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.debug.GraalError; import jdk.graal.compiler.nodes.ConstantNode; import jdk.graal.compiler.nodes.ValueNode; @@ -115,7 +114,6 @@ static class Options { private static final Object NULL_MARKER = new Object(); private final ImageClassLoader imageClassLoader; - private final SnippetReflectionProvider snippetReflection; private final AnnotationSubstitutionProcessor annotationSubstitutions; private final ClassInitializationPlugin classInitializationPlugin; private final AnalysisUniverse aUniverse; @@ -123,10 +121,9 @@ static class Options { private final FallbackFeature fallbackFeature; private final ClassInitializationSupport classInitializationSupport; - private ReflectionPlugins(ImageClassLoader imageClassLoader, SnippetReflectionProvider snippetReflection, AnnotationSubstitutionProcessor annotationSubstitutions, + private ReflectionPlugins(ImageClassLoader imageClassLoader, AnnotationSubstitutionProcessor annotationSubstitutions, ClassInitializationPlugin classInitializationPlugin, AnalysisUniverse aUniverse, ParsingReason reason, FallbackFeature fallbackFeature) { this.imageClassLoader = imageClassLoader; - this.snippetReflection = snippetReflection; this.annotationSubstitutions = annotationSubstitutions; this.classInitializationPlugin = classInitializationPlugin; this.aUniverse = aUniverse; @@ -136,9 +133,9 @@ private ReflectionPlugins(ImageClassLoader imageClassLoader, SnippetReflectionPr this.classInitializationSupport = (ClassInitializationSupport) ImageSingletons.lookup(RuntimeClassInitializationSupport.class); } - public static void registerInvocationPlugins(ImageClassLoader imageClassLoader, SnippetReflectionProvider snippetReflection, AnnotationSubstitutionProcessor annotationSubstitutions, + public static void registerInvocationPlugins(ImageClassLoader imageClassLoader, AnnotationSubstitutionProcessor annotationSubstitutions, ClassInitializationPlugin classInitializationPlugin, InvocationPlugins plugins, AnalysisUniverse aUniverse, ParsingReason reason, FallbackFeature fallbackFeature) { - ReflectionPlugins rp = new ReflectionPlugins(imageClassLoader, snippetReflection, annotationSubstitutions, classInitializationPlugin, aUniverse, reason, fallbackFeature); + ReflectionPlugins rp = new ReflectionPlugins(imageClassLoader, annotationSubstitutions, classInitializationPlugin, aUniverse, reason, fallbackFeature); rp.registerMethodHandlesPlugins(plugins); rp.registerClassPlugins(plugins); } @@ -590,7 +587,7 @@ private Object unbox(GraphBuilderContext b, ValueNode arg, JavaKind argKind) { * If the argument is not a constant, we try to extract a varargs-parameter list for * Class[] arrays. This is used in many reflective lookup methods. */ - return SubstrateGraphBuilderPlugins.extractClassArray(b, annotationSubstitutions, snippetReflection, arg, true); + return SubstrateGraphBuilderPlugins.extractClassArray(b, annotationSubstitutions, arg, true); } JavaConstant argConstant = arg.asJavaConstant(); @@ -621,7 +618,7 @@ private Object unbox(GraphBuilderContext b, ValueNode arg, JavaKind argKind) { } } - private Object unboxObjectConstant(GraphBuilderContext b, JavaConstant argConstant) { + private static Object unboxObjectConstant(GraphBuilderContext b, JavaConstant argConstant) { ResolvedJavaType javaType = b.getConstantReflection().asJavaType(argConstant); if (javaType != null) { /* @@ -634,7 +631,7 @@ private Object unboxObjectConstant(GraphBuilderContext b, JavaConstant argConsta } /* Any other object that is not a Class. */ - Object result = snippetReflection.asObject(Object.class, argConstant); + Object result = b.getSnippetReflection().asObject(Object.class, argConstant); if (result != null && isAllowedConstant(result.getClass())) { return result; } @@ -712,7 +709,7 @@ private JavaConstant pushConstant(GraphBuilderContext b, ResolvedJavaMethod targ } else if (intrinsicValue == NULL_MARKER) { intrinsicConstant = JavaConstant.NULL_POINTER; } else { - intrinsicConstant = snippetReflection.forObject(intrinsicValue); + intrinsicConstant = b.getSnippetReflection().forObject(intrinsicValue); } b.addPush(returnKind, ConstantNode.forConstant(intrinsicConstant, b.getMetaAccess())); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/SubstrateGraphBuilderPlugins.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/SubstrateGraphBuilderPlugins.java index dd1a0d382922..d3a4b5defc54 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/SubstrateGraphBuilderPlugins.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/SubstrateGraphBuilderPlugins.java @@ -100,7 +100,6 @@ import com.oracle.svm.hosted.substitute.AnnotationSubstitutionProcessor; import com.oracle.svm.util.ClassUtil; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.CompressEncoding; import jdk.graal.compiler.core.common.type.AbstractObjectStamp; import jdk.graal.compiler.core.common.type.IntegerStamp; @@ -181,7 +180,6 @@ public static class Options { public static void registerInvocationPlugins(AnnotationSubstitutionProcessor annotationSubstitutions, ImageClassLoader loader, - SnippetReflectionProvider snippetReflection, InvocationPlugins plugins, Replacements replacements, ParsingReason parsingReason, @@ -189,22 +187,22 @@ public static void registerInvocationPlugins(AnnotationSubstitutionProcessor ann boolean supportsStubBasedPlugins) { // register the substratevm plugins - registerSystemPlugins(snippetReflection, plugins); + registerSystemPlugins(plugins); registerReflectionPlugins(plugins, replacements); registerImageInfoPlugins(plugins); - registerProxyPlugins(snippetReflection, annotationSubstitutions, plugins, parsingReason); - registerSerializationPlugins(loader, snippetReflection, plugins, parsingReason); - registerAtomicUpdaterPlugins(snippetReflection, plugins); + registerProxyPlugins(annotationSubstitutions, plugins, parsingReason); + registerSerializationPlugins(loader, plugins, parsingReason); + registerAtomicUpdaterPlugins(plugins); registerObjectPlugins(plugins); - registerUnsafePlugins(plugins, snippetReflection); + registerUnsafePlugins(plugins); registerKnownIntrinsicsPlugins(plugins); - registerStackValuePlugins(snippetReflection, plugins); - registerArrayPlugins(plugins, snippetReflection, parsingReason); - registerClassPlugins(plugins, snippetReflection); + registerStackValuePlugins(plugins); + registerArrayPlugins(plugins); + registerClassPlugins(plugins); registerEdgesPlugins(plugins); - registerVMConfigurationPlugins(snippetReflection, plugins); - registerPlatformPlugins(snippetReflection, plugins); - registerSizeOfPlugins(snippetReflection, plugins); + registerVMConfigurationPlugins(plugins); + registerPlatformPlugins(plugins); + registerSizeOfPlugins(plugins); registerReferencePlugins(plugins, parsingReason); registerReferenceAccessPlugins(plugins); if (supportsStubBasedPlugins) { @@ -213,7 +211,7 @@ public static void registerInvocationPlugins(AnnotationSubstitutionProcessor ann } } - private static void registerSerializationPlugins(ImageClassLoader loader, SnippetReflectionProvider snippetReflection, InvocationPlugins plugins, ParsingReason reason) { + private static void registerSerializationPlugins(ImageClassLoader loader, InvocationPlugins plugins, ParsingReason reason) { if (reason.duringAnalysis() && reason != ParsingReason.JITCompilation) { Registration serializationFilter = new Registration(plugins, ObjectInputFilter.Config.class); serializationFilter.register(new RequiredInvocationPlugin("createFilter", String.class) { @@ -225,7 +223,7 @@ public boolean isDecorator() { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode patternNode) { if (nonNullJavaConstants(patternNode)) { - String pattern = snippetReflection.asObject(String.class, patternNode.asJavaConstant()); + String pattern = b.getSnippetReflection().asObject(String.class, patternNode.asJavaConstant()); b.add(ReachabilityRegistrationNode.create(() -> parsePatternAndRegister(pattern), reason)); return true; } @@ -244,7 +242,7 @@ public boolean isDecorator() { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode clazz) { if (nonNullJavaConstants(receiver.get(), clazz)) { - b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(snippetReflection.asObject(Class.class, clazz.asJavaConstant())), reason)); + b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.register(b.getSnippetReflection().asObject(Class.class, clazz.asJavaConstant())), reason)); return true; } return false; @@ -260,9 +258,10 @@ public boolean isDecorator() { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode clazz, ValueNode constructor) { if (nonNullJavaConstants(receiver.get(), clazz, constructor)) { - var constructorDeclaringClass = snippetReflection.asObject(Constructor.class, constructor.asJavaConstant()).getDeclaringClass(); - b.add(ReachabilityRegistrationNode.create(() -> RuntimeSerialization.registerWithTargetConstructorClass(snippetReflection.asObject(Class.class, clazz.asJavaConstant()), - constructorDeclaringClass), reason)); + var constructorDeclaringClass = b.getSnippetReflection().asObject(Constructor.class, constructor.asJavaConstant()).getDeclaringClass(); + b.add(ReachabilityRegistrationNode + .create(() -> RuntimeSerialization.registerWithTargetConstructorClass(b.getSnippetReflection().asObject(Class.class, clazz.asJavaConstant()), + constructorDeclaringClass), reason)); return true; } return false; @@ -355,14 +354,14 @@ private static void parsePatternAndRegister(String pattern) { } } - private static void registerSystemPlugins(SnippetReflectionProvider snippetReflection, InvocationPlugins plugins) { + private static void registerSystemPlugins(InvocationPlugins plugins) { Registration r = new Registration(plugins, System.class); if (SubstrateOptions.FoldSecurityManagerGetter.getValue()) { r.register(new RequiredInvocationPlugin("getSecurityManager") { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { /* System.getSecurityManager() always returns null. */ - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReflection.forObject(null), b.getMetaAccess(), b.getGraph())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(null), b.getMetaAccess(), b.getGraph())); return true; } }); @@ -418,13 +417,13 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec }); } - private static void registerProxyPlugins(SnippetReflectionProvider snippetReflection, AnnotationSubstitutionProcessor annotationSubstitutions, InvocationPlugins plugins, ParsingReason reason) { + private static void registerProxyPlugins(AnnotationSubstitutionProcessor annotationSubstitutions, InvocationPlugins plugins, ParsingReason reason) { Registration proxyRegistration = new Registration(plugins, Proxy.class); - registerProxyPlugin(proxyRegistration, snippetReflection, annotationSubstitutions, reason, "getProxyClass", ClassLoader.class, Class[].class); - registerProxyPlugin(proxyRegistration, snippetReflection, annotationSubstitutions, reason, "newProxyInstance", ClassLoader.class, Class[].class, InvocationHandler.class); + registerProxyPlugin(proxyRegistration, annotationSubstitutions, reason, "getProxyClass", ClassLoader.class, Class[].class); + registerProxyPlugin(proxyRegistration, annotationSubstitutions, reason, "newProxyInstance", ClassLoader.class, Class[].class, InvocationHandler.class); } - private static void registerProxyPlugin(Registration proxyRegistration, SnippetReflectionProvider snippetReflection, AnnotationSubstitutionProcessor annotationSubstitutions, ParsingReason reason, + private static void registerProxyPlugin(Registration proxyRegistration, AnnotationSubstitutionProcessor annotationSubstitutions, ParsingReason reason, String name, Class... parameterTypes) { proxyRegistration.register(new RequiredInvocationPlugin(name, parameterTypes) { @Override @@ -434,7 +433,7 @@ public boolean isDecorator() { @Override public boolean defaultHandler(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode... args) { - Runnable proxyRegistrationRunnable = interceptProxyInterfaces(b, targetMethod, snippetReflection, annotationSubstitutions, args[1]); + Runnable proxyRegistrationRunnable = interceptProxyInterfaces(b, targetMethod, annotationSubstitutions, args[1]); if (proxyRegistrationRunnable != null) { Class callerClass = OriginalClassProvider.getJavaClass(b.getMethod().getDeclaringClass()); boolean callerInScope = MissingRegistrationSupport.singleton().reportMissingRegistrationErrors(callerClass.getModule().getName(), callerClass.getPackageName(), @@ -456,9 +455,8 @@ public boolean defaultHandler(GraphBuilderContext b, ResolvedJavaMethod targetMe * Try to intercept proxy interfaces passed in as literal constants, and register the interfaces * in the {@link DynamicProxyRegistry}. */ - private static Runnable interceptProxyInterfaces(GraphBuilderContext b, ResolvedJavaMethod targetMethod, SnippetReflectionProvider snippetReflection, - AnnotationSubstitutionProcessor annotationSubstitutions, ValueNode interfacesNode) { - Class[] interfaces = extractClassArray(b, snippetReflection, annotationSubstitutions, interfacesNode); + private static Runnable interceptProxyInterfaces(GraphBuilderContext b, ResolvedJavaMethod targetMethod, AnnotationSubstitutionProcessor annotationSubstitutions, ValueNode interfacesNode) { + Class[] interfaces = extractClassArray(b, annotationSubstitutions, interfacesNode); if (interfaces != null) { var caller = b.getGraph().method(); var method = b.getMethod(); @@ -487,8 +485,8 @@ private static Runnable interceptProxyInterfaces(GraphBuilderContext b, Resolved * Try to extract a Class array from a ValueNode. It does not guarantee that the array content * will not change. */ - static Class[] extractClassArray(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, AnnotationSubstitutionProcessor annotationSubstitutions, ValueNode arrayNode) { - Class[] classes = extractClassArray(b, annotationSubstitutions, snippetReflection, arrayNode, false); + static Class[] extractClassArray(GraphBuilderContext b, AnnotationSubstitutionProcessor annotationSubstitutions, ValueNode arrayNode) { + Class[] classes = extractClassArray(b, annotationSubstitutions, arrayNode, false); /* * If any of the element is null just bailout, this is probably a situation where the array * will be filled in later and we don't track that. @@ -507,8 +505,7 @@ static Class[] extractClassArray(GraphBuilderContext b, SnippetReflectionProv * constants and there is no control flow split. If the content of the array cannot be * determined a null value is returned. */ - static Class[] extractClassArray(GraphBuilderContext b, AnnotationSubstitutionProcessor annotationSubstitutions, SnippetReflectionProvider snippetReflection, ValueNode arrayNode, - boolean exact) { + static Class[] extractClassArray(GraphBuilderContext b, AnnotationSubstitutionProcessor annotationSubstitutions, ValueNode arrayNode, boolean exact) { /* Use the original value in case we are in a deopt target method. */ ValueNode originalArrayNode = getDeoptProxyOriginalValue(arrayNode); if (originalArrayNode.isJavaConstant() && !exact) { @@ -516,7 +513,7 @@ static Class[] extractClassArray(GraphBuilderContext b, AnnotationSubstitutio * The array is a constant, however that doesn't make the array immutable, i.e., its * elements can still be changed. We assume that will not happen. */ - return snippetReflection.asObject(Class[].class, originalArrayNode.asJavaConstant()); + return b.getSnippetReflection().asObject(Class[].class, originalArrayNode.asJavaConstant()); } else if (originalArrayNode instanceof AllocatedObjectNode && StampTool.isAlwaysArray(originalArrayNode)) { AllocatedObjectNode allocatedObjectNode = (AllocatedObjectNode) originalArrayNode; @@ -539,7 +536,7 @@ static Class[] extractClassArray(GraphBuilderContext b, AnnotationSubstitutio Class[] result = new Class[virtualObject.entryCount()]; for (int i = 0; i < result.length; i++) { JavaConstant valueConstant = commitAllocationNode.getValues().get(objectStartIndex + i).asJavaConstant(); - if (!storeClassArrayConstant(result, i, valueConstant, annotationSubstitutions, snippetReflection)) { + if (!storeClassArrayConstant(b, result, i, valueConstant, annotationSubstitutions)) { return null; } } @@ -585,7 +582,7 @@ static Class[] extractClassArray(GraphBuilderContext b, AnnotationSubstitutio } int index = store.index().asJavaConstant().asInt(); JavaConstant valueConstant = store.value().asJavaConstant(); - if (!storeClassArrayConstant(result, index, valueConstant, annotationSubstitutions, snippetReflection)) { + if (!storeClassArrayConstant(b, result, index, valueConstant, annotationSubstitutions)) { return null; } } @@ -601,16 +598,14 @@ static Class[] extractClassArray(GraphBuilderContext b, AnnotationSubstitutio return null; } - private static boolean storeClassArrayConstant(Class[] result, int index, JavaConstant valueConstant, - AnnotationSubstitutionProcessor annotationSubstitutions, SnippetReflectionProvider snippetReflection) { - + private static boolean storeClassArrayConstant(GraphBuilderContext b, Class[] result, int index, JavaConstant valueConstant, AnnotationSubstitutionProcessor annotationSubstitutions) { if (valueConstant == null || valueConstant.getJavaKind() != JavaKind.Object) { return false; } if (valueConstant.isNull()) { result[index] = null; } else { - Class clazz = snippetReflection.asObject(Class.class, valueConstant); + Class clazz = b.getSnippetReflection().asObject(Class.class, valueConstant); if (clazz == null) { return false; } @@ -667,12 +662,12 @@ private static FixedNode unwrapNode(FixedNode node) { } } - private static void registerAtomicUpdaterPlugins(SnippetReflectionProvider snippetReflection, InvocationPlugins plugins) { + private static void registerAtomicUpdaterPlugins(InvocationPlugins plugins) { Registration referenceUpdaterRegistration = new Registration(plugins, AtomicReferenceFieldUpdater.class); referenceUpdaterRegistration.register(new RequiredInvocationPlugin("newUpdater", Class.class, Class.class, String.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode tclassNode, ValueNode vclassNode, ValueNode fieldNameNode) { - interceptUpdaterInvoke(b, snippetReflection, tclassNode, fieldNameNode); + interceptUpdaterInvoke(b, tclassNode, fieldNameNode); /* Always return false; the call is not replaced. */ return false; } @@ -682,7 +677,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec integerUpdaterRegistration.register(new RequiredInvocationPlugin("newUpdater", Class.class, String.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode tclassNode, ValueNode fieldNameNode) { - interceptUpdaterInvoke(b, snippetReflection, tclassNode, fieldNameNode); + interceptUpdaterInvoke(b, tclassNode, fieldNameNode); /* Always return false; the call is not replaced. */ return false; } @@ -692,7 +687,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec longUpdaterRegistration.register(new RequiredInvocationPlugin("newUpdater", Class.class, String.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode tclassNode, ValueNode fieldNameNode) { - interceptUpdaterInvoke(b, snippetReflection, tclassNode, fieldNameNode); + interceptUpdaterInvoke(b, tclassNode, fieldNameNode); /* Always return false; the call is not replaced. */ return false; } @@ -704,10 +699,10 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec * them for reflection/unsafe access. */ @SuppressWarnings("unused") - private static void interceptUpdaterInvoke(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, ValueNode tclassNode, ValueNode fieldNameNode) { + private static void interceptUpdaterInvoke(GraphBuilderContext b, ValueNode tclassNode, ValueNode fieldNameNode) { if (tclassNode.isConstant() && fieldNameNode.isConstant()) { - Class tclass = snippetReflection.asObject(Class.class, tclassNode.asJavaConstant()); - String fieldName = snippetReflection.asObject(String.class, fieldNameNode.asJavaConstant()); + Class tclass = b.getSnippetReflection().asObject(Class.class, tclassNode.asJavaConstant()); + String fieldName = b.getSnippetReflection().asObject(String.class, fieldNameNode.asJavaConstant()); try { Field field = tclass.getDeclaredField(fieldName); /* @@ -749,10 +744,10 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec }); } - private static void registerUnsafePlugins(InvocationPlugins plugins, SnippetReflectionProvider snippetReflection) { - registerUnsafePlugins(new Registration(plugins, "sun.misc.Unsafe"), snippetReflection, true); + private static void registerUnsafePlugins(InvocationPlugins plugins) { + registerUnsafePlugins(new Registration(plugins, "sun.misc.Unsafe"), true); Registration r = new Registration(plugins, "jdk.internal.misc.Unsafe"); - registerUnsafePlugins(r, snippetReflection, false); + registerUnsafePlugins(r, false); r.register(new RequiredInvocationPlugin("objectFieldOffset", Receiver.class, Class.class, String.class) { @Override @@ -762,8 +757,8 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec receiver.get(); /* If the class and field name arguments are constant. */ - Class clazz = snippetReflection.asObject(Class.class, classNode.asJavaConstant()); - String fieldName = snippetReflection.asObject(String.class, nameNode.asJavaConstant()); + Class clazz = b.getSnippetReflection().asObject(Class.class, classNode.asJavaConstant()); + String fieldName = b.getSnippetReflection().asObject(String.class, nameNode.asJavaConstant()); try { Field targetField = clazz.getDeclaredField(fieldName); return processFieldOffset(b, targetField, false); @@ -782,7 +777,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec r.register(new AllocateUninitializedArrayPlugin("allocateUninitializedArray", true)); } - private static void registerUnsafePlugins(Registration r, SnippetReflectionProvider snippetReflection, boolean isSunMiscUnsafe) { + private static void registerUnsafePlugins(Registration r, boolean isSunMiscUnsafe) { r.register(new RequiredInvocationPlugin("staticFieldOffset", Receiver.class, Field.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode fieldNode) { @@ -790,7 +785,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec // Emits a null-check for the otherwise unused receiver receiver.get(); - Field targetField = snippetReflection.asObject(Field.class, fieldNode.asJavaConstant()); + Field targetField = b.getSnippetReflection().asObject(Field.class, fieldNode.asJavaConstant()); return processFieldOffset(b, targetField, isSunMiscUnsafe); } return false; @@ -803,7 +798,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec // Emits a null-check for the otherwise unused receiver receiver.get(); - Field targetField = snippetReflection.asObject(Field.class, fieldNode.asJavaConstant()); + Field targetField = b.getSnippetReflection().asObject(Field.class, fieldNode.asJavaConstant()); return processStaticFieldBase(b, targetField, isSunMiscUnsafe); } return false; @@ -817,7 +812,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec // Emits a null-check for the otherwise unused receiver receiver.get(); - Field targetField = snippetReflection.asObject(Field.class, fieldNode.asJavaConstant()); + Field targetField = b.getSnippetReflection().asObject(Field.class, fieldNode.asJavaConstant()); return processFieldOffset(b, targetField, isSunMiscUnsafe); } return false; @@ -881,7 +876,7 @@ private static boolean processStaticFieldBase(GraphBuilderContext b, Field targe } @SuppressWarnings("unused") - private static void registerArrayPlugins(InvocationPlugins plugins, SnippetReflectionProvider snippetReflection, ParsingReason reason) { + private static void registerArrayPlugins(InvocationPlugins plugins) { Registration r = new Registration(plugins, Array.class).setAllowOverwrite(true); r.register(new RequiredInvocationPlugin("newInstance", Class.class, int[].class) { @Override @@ -894,7 +889,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec */ ValueNode dimensionCountNode = GraphUtil.arrayLength(dimensionsNode, ArrayLengthProvider.FindLengthMode.SEARCH_ONLY, b.getConstantReflection()); if (clazzNode.isConstant() && !clazzNode.isNullConstant() && dimensionCountNode != null && dimensionCountNode.isConstant()) { - Class clazz = snippetReflection.asObject(Class.class, clazzNode.asJavaConstant()); + Class clazz = b.getSnippetReflection().asObject(Class.class, clazzNode.asJavaConstant()); int dimensionCount = dimensionCountNode.asJavaConstant().asInt(); AnalysisType type = (AnalysisType) b.getMetaAccess().lookupJavaType(clazz); @@ -1016,9 +1011,9 @@ private static IntegerStamp nonZeroWord() { return StampFactory.forUnsignedInteger(64, 1, 0xffffffffffffffffL); } - private static void registerStackValuePlugins(SnippetReflectionProvider snippetReflection, InvocationPlugins plugins) { - registerStackValuePlugins(snippetReflection, new Registration(plugins, StackValue.class), true); - registerStackValuePlugins(snippetReflection, new Registration(plugins, UnsafeStackValue.class), false); + private static void registerStackValuePlugins(InvocationPlugins plugins) { + registerStackValuePlugins(new Registration(plugins, StackValue.class), true); + registerStackValuePlugins(new Registration(plugins, UnsafeStackValue.class), false); Registration unsafeLateStackValue = new Registration(plugins, UnsafeLateStackValue.class); unsafeLateStackValue.register(new RequiredInvocationPlugin("get", int.class) { @@ -1030,7 +1025,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec }); } - private static void registerStackValuePlugins(SnippetReflectionProvider snippetReflection, Registration r, boolean disallowVirtualThread) { + private static void registerStackValuePlugins(Registration r, boolean disallowVirtualThread) { r.register(new RequiredInvocationPlugin("get", int.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode sizeNode) { @@ -1043,7 +1038,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec @SuppressWarnings("unchecked") @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode classNode) { - Class clazz = constantObjectParameter(b, snippetReflection, targetMethod, 0, Class.class, classNode); + Class clazz = constantObjectParameter(b, targetMethod, 0, Class.class, classNode); int size = SizeOf.get(clazz); b.addPush(JavaKind.Object, StackValueNode.create(1, size, b, disallowVirtualThread)); return true; @@ -1063,7 +1058,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode numElementsNode, ValueNode classNode) { long numElements = longValue(b, targetMethod, numElementsNode, "numElements"); - Class clazz = constantObjectParameter(b, snippetReflection, targetMethod, 0, Class.class, classNode); + Class clazz = constantObjectParameter(b, targetMethod, 0, Class.class, classNode); int size = SizeOf.get(clazz); b.addPush(JavaKind.Object, StackValueNode.create(numElements, size, b, disallowVirtualThread)); return true; @@ -1071,7 +1066,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec }); } - private static void registerClassPlugins(InvocationPlugins plugins, SnippetReflectionProvider snippetReflection) { + private static void registerClassPlugins(InvocationPlugins plugins) { Registration r = new Registration(plugins, Class.class); /* * The field DynamicHub.name cannot be final, so we ensure early constant folding using an @@ -1099,17 +1094,17 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec } }); - registerClassDesiredAssertionStatusPlugin(plugins, snippetReflection); + registerClassDesiredAssertionStatusPlugin(plugins); } - public static void registerClassDesiredAssertionStatusPlugin(InvocationPlugins plugins, SnippetReflectionProvider snippetReflection) { + public static void registerClassDesiredAssertionStatusPlugin(InvocationPlugins plugins) { Registration r = new Registration(plugins, Class.class); r.register(new RequiredInvocationPlugin("desiredAssertionStatus", Receiver.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { JavaConstant constantReceiver = receiver.get().asJavaConstant(); if (constantReceiver != null && constantReceiver.isNonNull()) { - Object clazzOrHub = snippetReflection.asObject(Object.class, constantReceiver); + Object clazzOrHub = b.getSnippetReflection().asObject(Object.class, constantReceiver); boolean desiredAssertionStatus; if (clazzOrHub instanceof Class) { desiredAssertionStatus = RuntimeAssertionsSupport.singleton().desiredAssertionStatus((Class) clazzOrHub); @@ -1154,12 +1149,12 @@ protected static long longValue(GraphBuilderContext b, ResolvedJavaMethod target return node.asJavaConstant().asLong(); } - private static void registerVMConfigurationPlugins(SnippetReflectionProvider snippetReflection, InvocationPlugins plugins) { + private static void registerVMConfigurationPlugins(InvocationPlugins plugins) { Registration r = new Registration(plugins, ImageSingletons.class); r.register(new RequiredInvocationPlugin("contains", Class.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode classNode) { - Class key = constantObjectParameter(b, snippetReflection, targetMethod, 0, Class.class, classNode); + Class key = constantObjectParameter(b, targetMethod, 0, Class.class, classNode); boolean result = ImageSingletons.contains(key); b.addPush(JavaKind.Boolean, ConstantNode.forBoolean(result)); return true; @@ -1168,21 +1163,21 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec r.register(new RequiredInvocationPlugin("lookup", Class.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode classNode) { - Class key = constantObjectParameter(b, snippetReflection, targetMethod, 0, Class.class, classNode); + Class key = constantObjectParameter(b, targetMethod, 0, Class.class, classNode); Object result = ImageSingletons.lookup(key); - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReflection.forObject(result), b.getMetaAccess())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(result), b.getMetaAccess())); return true; } }); } - private static void registerPlatformPlugins(SnippetReflectionProvider snippetReflection, InvocationPlugins plugins) { + private static void registerPlatformPlugins(InvocationPlugins plugins) { Registration r = new Registration(plugins, Platform.class); r.register(new RequiredInvocationPlugin("includedIn", Class.class) { @SuppressWarnings("unchecked") @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode classNode) { - Class platform = constantObjectParameter(b, snippetReflection, targetMethod, 0, Class.class, classNode); + Class platform = constantObjectParameter(b, targetMethod, 0, Class.class, classNode); boolean result = Platform.includedIn(platform); b.addPush(JavaKind.Boolean, ConstantNode.forBoolean(result)); return true; @@ -1190,13 +1185,13 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec }); } - private static void registerSizeOfPlugins(SnippetReflectionProvider snippetReflection, InvocationPlugins plugins) { + private static void registerSizeOfPlugins(InvocationPlugins plugins) { Registration r = new Registration(plugins, SizeOf.class); r.register(new RequiredInvocationPlugin("get", Class.class) { @SuppressWarnings("unchecked") @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode classNode) { - Class clazz = constantObjectParameter(b, snippetReflection, targetMethod, 0, Class.class, classNode); + Class clazz = constantObjectParameter(b, targetMethod, 0, Class.class, classNode); int result = SizeOf.get(clazz); b.addPush(JavaKind.Int, ConstantNode.forInt(result)); return true; @@ -1206,9 +1201,9 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec @SuppressWarnings("unchecked") @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode classNode) { - Class clazz = constantObjectParameter(b, snippetReflection, targetMethod, 0, Class.class, classNode); + Class clazz = constantObjectParameter(b, targetMethod, 0, Class.class, classNode); UnsignedWord result = SizeOf.unsigned(clazz); - b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReflection.forObject(result), b.getMetaAccess())); + b.addPush(JavaKind.Object, ConstantNode.forConstant(b.getSnippetReflection().forObject(result), b.getMetaAccess())); return true; } }); @@ -1324,10 +1319,9 @@ protected ResolvedJavaType getTypeAESCrypt(MetaAccessProvider metaAccess, Resolv r.registerConditional(CipherBlockChainingAESNode.isSupported(arch), new SubstrateCipherBlockChainingCryptPlugin(AESNode.CryptMode.DECRYPT)); } - private static T constantObjectParameter(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, ResolvedJavaMethod targetMethod, int parameterIndex, Class declaredType, - ValueNode classNode) { + private static T constantObjectParameter(GraphBuilderContext b, ResolvedJavaMethod targetMethod, int parameterIndex, Class declaredType, ValueNode classNode) { checkParameterUsage(classNode.isConstant(), b, targetMethod, parameterIndex, "parameter is not a compile time constant"); - T result = snippetReflection.asObject(declaredType, classNode.asJavaConstant()); + T result = b.getSnippetReflection().asObject(declaredType, classNode.asJavaConstant()); checkParameterUsage(result != null, b, targetMethod, parameterIndex, "parameter is null"); return result; } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AutomaticUnsafeTransformationSupport.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AutomaticUnsafeTransformationSupport.java index c4c3b498a18e..7c5f1beadb6d 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AutomaticUnsafeTransformationSupport.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AutomaticUnsafeTransformationSupport.java @@ -68,7 +68,6 @@ import com.oracle.svm.util.LogUtils; import com.oracle.svm.util.ReflectionUtil; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.debug.DebugContext; import jdk.graal.compiler.debug.DebugContext.Builder; import jdk.graal.compiler.graph.Node; @@ -252,7 +251,7 @@ public AutomaticUnsafeTransformationSupport(OptionValues options, AnnotationSubs plugins.setClassInitializationPlugin(classInitializationPlugin); FallbackFeature fallbackFeature = ImageSingletons.contains(FallbackFeature.class) ? ImageSingletons.lookup(FallbackFeature.class) : null; - ReflectionPlugins.registerInvocationPlugins(loader, GraalAccess.getOriginalSnippetReflection(), annotationSubstitutions, classInitializationPlugin, plugins.getInvocationPlugins(), null, + ReflectionPlugins.registerInvocationPlugins(loader, annotationSubstitutions, classInitializationPlugin, plugins.getInvocationPlugins(), null, ParsingReason.AutomaticUnsafeTransformation, fallbackFeature); /* @@ -515,15 +514,13 @@ private void processUnsafeFieldComputation(BigBang bb, ResolvedJavaType type, In * static final long arrayBaseOffsets = Unsafe.getUnsafe().arrayBaseOffset(byte[].class); */ private void processUnsafeArrayBaseOffsetInvoke(BigBang bb, ResolvedJavaType type, Invoke unsafeArrayBaseOffsetInvoke) { - SnippetReflectionProvider snippetReflectionProvider = GraalAccess.getOriginalSnippetReflection(); - List> unsuccessfulReasons = new ArrayList<>(); Class arrayClass = null; ValueNode arrayClassArgument = unsafeArrayBaseOffsetInvoke.callTarget().arguments().get(1); if (arrayClassArgument.isJavaConstant()) { - arrayClass = snippetReflectionProvider.asObject(Class.class, arrayClassArgument.asJavaConstant()); + arrayClass = GraalAccess.getOriginalSnippetReflection().asObject(Class.class, arrayClassArgument.asJavaConstant()); } else { unsuccessfulReasons.add(() -> "The argument of the call to Unsafe.arrayBaseOffset() is not a constant."); } @@ -556,15 +553,13 @@ private void processUnsafeArrayBaseOffsetInvoke(BigBang bb, ResolvedJavaType typ * static final long byteArrayIndexScale = Unsafe.getUnsafe().arrayIndexScale(byte[].class); */ private void processUnsafeArrayIndexScaleInvoke(BigBang bb, ResolvedJavaType type, Invoke unsafeArrayIndexScale, StructuredGraph clinitGraph) { - SnippetReflectionProvider snippetReflectionProvider = GraalAccess.getOriginalSnippetReflection(); - List> unsuccessfulReasons = new ArrayList<>(); Class arrayClass = null; ValueNode arrayClassArgument = unsafeArrayIndexScale.callTarget().arguments().get(1); if (arrayClassArgument.isJavaConstant()) { - arrayClass = snippetReflectionProvider.asObject(Class.class, arrayClassArgument.asJavaConstant()); + arrayClass = GraalAccess.getOriginalSnippetReflection().asObject(Class.class, arrayClassArgument.asJavaConstant()); } else { unsuccessfulReasons.add(() -> "The argument of the call to Unsafe.arrayIndexScale() is not a constant."); } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadLocalCollector.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadLocalCollector.java index 499bdeecaa21..1123333a2c91 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadLocalCollector.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadLocalCollector.java @@ -31,17 +31,16 @@ import java.util.Map; import java.util.function.Function; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; -import jdk.graal.compiler.core.common.NumUtil; -import jdk.graal.compiler.nodes.PiNode; -import jdk.graal.compiler.nodes.ValueNode; -import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; - import com.oracle.svm.core.config.ConfigurationValues; import com.oracle.svm.core.threadlocal.FastThreadLocal; import com.oracle.svm.core.threadlocal.VMThreadLocalInfo; import com.oracle.svm.core.util.ObservableImageHeapMapProvider; +import jdk.graal.compiler.core.common.NumUtil; +import jdk.graal.compiler.nodes.PiNode; +import jdk.graal.compiler.nodes.ValueNode; +import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; + /** * Collects all {@link FastThreadLocal} instances that are actually used by the application. */ @@ -73,12 +72,12 @@ public VMThreadLocalInfo getInfo(FastThreadLocal threadLocal) { return result; } - public VMThreadLocalInfo findInfo(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, ValueNode threadLocalNode) { + public VMThreadLocalInfo findInfo(GraphBuilderContext b, ValueNode threadLocalNode) { if (!threadLocalNode.isConstant()) { throw shouldNotReachHere("Accessed VMThreadLocal is not a compile time constant: " + b.getMethod().asStackTraceElement(b.bci()) + " - node " + unPi(threadLocalNode)); } - FastThreadLocal threadLocal = snippetReflection.asObject(FastThreadLocal.class, threadLocalNode.asJavaConstant()); + FastThreadLocal threadLocal = b.getSnippetReflection().asObject(FastThreadLocal.class, threadLocalNode.asJavaConstant()); VMThreadLocalInfo result = threadLocals.get(threadLocal); assert result != null; return result; diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadMTFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadMTFeature.java index d6305aac8623..8146af0fb8fe 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadMTFeature.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/thread/VMThreadMTFeature.java @@ -52,7 +52,6 @@ import com.oracle.svm.core.threadlocal.VMThreadLocalMTSupport; import com.oracle.svm.core.util.VMError; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.NumUtil; import jdk.graal.compiler.core.common.memory.BarrierType; import jdk.graal.compiler.core.common.memory.MemoryOrderMode; @@ -97,26 +96,26 @@ public void duringSetup(DuringSetupAccess config) { * access memory that we manage ourselfs. */ @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { for (Class threadLocalClass : VMThreadLocalInfo.THREAD_LOCAL_CLASSES) { Registration r = new Registration(plugins.getInvocationPlugins(), threadLocalClass); Class valueClass = VMThreadLocalInfo.getValueClass(threadLocalClass); - registerAccessors(r, snippetReflection, valueClass, false); - registerAccessors(r, snippetReflection, valueClass, true); + registerAccessors(r, valueClass, false); + registerAccessors(r, valueClass, true); /* compareAndSet() method without the VMThread parameter. */ r.register(new RequiredInvocationPlugin("compareAndSet", Receiver.class, valueClass, valueClass) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode expect, ValueNode update) { ValueNode threadNode = currentThread(b); - return handleCompareAndSet(b, snippetReflection, targetMethod, receiver, threadNode, expect, update); + return handleCompareAndSet(b, targetMethod, receiver, threadNode, expect, update); } }); /* get() method with the VMThread parameter. */ r.register(new RequiredInvocationPlugin("compareAndSet", Receiver.class, IsolateThread.class, valueClass, valueClass) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode, ValueNode expect, ValueNode update) { - return handleCompareAndSet(b, snippetReflection, targetMethod, receiver, threadNode, expect, update); + return handleCompareAndSet(b, targetMethod, receiver, threadNode, expect, update); } }); } @@ -129,20 +128,20 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { ValueNode threadNode = currentThread(b); - return handleGetAddress(b, snippetReflection, targetMethod, receiver, threadNode); + return handleGetAddress(b, targetMethod, receiver, threadNode); } }); /* getAddress() method with the VMThread parameter. */ r.register(new RequiredInvocationPlugin("getAddress", Receiver.class, IsolateThread.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode) { - return handleGetAddress(b, snippetReflection, targetMethod, receiver, threadNode); + return handleGetAddress(b, targetMethod, receiver, threadNode); } }); } } - private void registerAccessors(Registration r, SnippetReflectionProvider snippetReflection, Class valueClass, boolean isVolatile) { + private void registerAccessors(Registration r, Class valueClass, boolean isVolatile) { String suffix = isVolatile ? "Volatile" : ""; /* get() method without the VMThread parameter. */ @@ -150,14 +149,14 @@ private void registerAccessors(Registration r, SnippetReflectionProvider snippet @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { ValueNode threadNode = currentThread(b); - return handleGet(b, snippetReflection, targetMethod, receiver, threadNode, isVolatile); + return handleGet(b, targetMethod, receiver, threadNode, isVolatile); } }); /* get() method with the VMThread parameter. */ r.register(new RequiredInvocationPlugin("get" + suffix, Receiver.class, IsolateThread.class) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode) { - return handleGet(b, snippetReflection, targetMethod, receiver, threadNode, isVolatile); + return handleGet(b, targetMethod, receiver, threadNode, isVolatile); } }); /* set() method without the VMThread parameter. */ @@ -165,14 +164,14 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode valueNode) { ValueNode threadNode = currentThread(b); - return handleSet(b, snippetReflection, receiver, threadNode, valueNode, isVolatile); + return handleSet(b, receiver, threadNode, valueNode, isVolatile); } }); /* set() method with the VMThread parameter. */ r.register(new RequiredInvocationPlugin("set" + suffix, Receiver.class, IsolateThread.class, valueClass) { @Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode, ValueNode valueNode) { - return handleSet(b, snippetReflection, receiver, threadNode, valueNode, isVolatile); + return handleSet(b, receiver, threadNode, valueNode, isVolatile); } }); } @@ -181,8 +180,8 @@ private static ValueNode currentThread(GraphBuilderContext b) { return b.add(ReadReservedRegister.createReadIsolateThreadNode(b.getGraph())); } - private boolean handleGet(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode, boolean isVolatile) { - VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, snippetReflection, receiver.get()); + private boolean handleGet(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode, boolean isVolatile) { + VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, receiver.get()); LoadVMThreadLocalNode node = new LoadVMThreadLocalNode(b.getMetaAccess(), threadLocalInfo, threadNode, BarrierType.NONE, isVolatile ? MemoryOrderMode.VOLATILE : MemoryOrderMode.PLAIN); b.addPush(targetMethod.getSignature().getReturnKind(), node); @@ -190,25 +189,25 @@ private boolean handleGet(GraphBuilderContext b, SnippetReflectionProvider snipp return true; } - private boolean handleSet(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, Receiver receiver, ValueNode threadNode, ValueNode valueNode, boolean isVolatile) { - VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, snippetReflection, receiver.get()); + private boolean handleSet(GraphBuilderContext b, Receiver receiver, ValueNode threadNode, ValueNode valueNode, boolean isVolatile) { + VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, receiver.get()); StoreVMThreadLocalNode store = b.add(new StoreVMThreadLocalNode(threadLocalInfo, threadNode, valueNode, BarrierType.NONE, isVolatile ? MemoryOrderMode.VOLATILE : MemoryOrderMode.PLAIN)); assert store.stateAfter() != null : store + " has no state after with graph builder context " + b; return true; } - private boolean handleCompareAndSet(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode, ValueNode expect, + private boolean handleCompareAndSet(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode, ValueNode expect, ValueNode update) { - VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, snippetReflection, receiver.get()); + VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, receiver.get()); CompareAndSetVMThreadLocalNode cas = new CompareAndSetVMThreadLocalNode(threadLocalInfo, threadNode, expect, update); b.addPush(targetMethod.getSignature().getReturnKind(), cas); assert cas.stateAfter() != null : cas + " has no state after with graph builder context " + b; return true; } - private boolean handleGetAddress(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode) { - VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, snippetReflection, receiver.get()); + private boolean handleGetAddress(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode threadNode) { + VMThreadLocalInfo threadLocalInfo = threadLocalCollector.findInfo(b, receiver.get()); b.addPush(targetMethod.getSignature().getReturnKind(), new AddressOfVMThreadLocalNode(threadLocalInfo, threadNode)); return true; } diff --git a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleBaseFeature.java b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleBaseFeature.java index fb5b55daaadd..05af62fabf00 100644 --- a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleBaseFeature.java +++ b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleBaseFeature.java @@ -139,7 +139,6 @@ import com.oracle.truffle.api.staticobject.StaticProperty; import com.oracle.truffle.api.staticobject.StaticShape; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.nodes.ConstantNode; import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; @@ -428,8 +427,7 @@ public void cleanup() { } @Override - public void registerInvocationPlugins(Providers providers, SnippetReflectionProvider snippetReflection, - Plugins plugins, ParsingReason reason) { + public void registerInvocationPlugins(Providers providers, Plugins plugins, ParsingReason reason) { StaticObjectSupport.registerInvocationPlugins(plugins, reason); TruffleInvocationPlugins.register(providers.getLowerer().getTarget().arch, plugins.getInvocationPlugins(), providers.getReplacements()); @@ -657,7 +655,7 @@ public void duringAnalysis(DuringAnalysisAccess a) { } @Override - public void registerGraalPhases(Providers providers, SnippetReflectionProvider snippetReflection, Suites suites, boolean hosted) { + public void registerGraalPhases(Providers providers, Suites suites, boolean hosted) { /* * Please keep this code in sync with the HotSpot configuration in * TruffleCommunityCompilerConfiguration. diff --git a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleFeature.java b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleFeature.java index b0a93c8d40cd..04e19533d5e8 100644 --- a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleFeature.java +++ b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleFeature.java @@ -151,7 +151,6 @@ import com.oracle.truffle.api.nodes.ExplodeLoop; import com.oracle.truffle.runtime.TruffleCallBoundary; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.phases.HighTier; import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.nodes.FrameState; @@ -355,7 +354,6 @@ public void beforeAnalysis(BeforeAnalysisAccess access) { "Truffle thread local foreign poll, registered in " + TruffleFeature.class); RuntimeCompilationFeature runtimeCompilationFeature = RuntimeCompilationFeature.singleton(); - SnippetReflectionProvider snippetReflection = runtimeCompilationFeature.getHostedProviders().getSnippetReflection(); SubstrateTruffleCompiler truffleCompiler = truffleRuntime.preinitializeTruffleCompiler(); truffleRuntime.initializeKnownMethods(config.getMetaAccess()); truffleRuntime.initializeHostedKnownMethods(config.getUniverse().getOriginalMetaAccess()); @@ -383,7 +381,7 @@ public void beforeAnalysis(BeforeAnalysisAccess access) { peProviders.getLowerer(), peProviders.getReplacements(), peProviders.getStampProvider(), - snippetReflection, + runtimeCompilationFeature.getHostedProviders().getSnippetReflection(), runtimeCompilationFeature.getHostedProviders().getWordTypes(), runtimeCompilationFeature.getHostedProviders().getPlatformConfigurationProvider(), runtimeCompilationFeature.getHostedProviders().getMetaAccessExtensionProvider(), @@ -996,7 +994,7 @@ private static void printStaticTruffleBoundaries(CallTreeInfo treeInfo) { } @Override - public void registerGraalPhases(Providers providers, SnippetReflectionProvider snippetReflection, Suites suites, boolean hosted) { + public void registerGraalPhases(Providers providers, Suites suites, boolean hosted) { /* * Please keep this code in sync with the HotSpot configuration in * TruffleCommunityCompilerConfiguration. diff --git a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleSupport.java b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleSupport.java index 71542b803ef0..7aeaf85488b4 100644 --- a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleSupport.java +++ b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleSupport.java @@ -56,7 +56,6 @@ import com.oracle.truffle.runtime.OptimizedCallTarget; import com.oracle.truffle.runtime.OptimizedDirectCallNode; -import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration; import jdk.graal.compiler.phases.util.Providers; import jdk.graal.compiler.truffle.EconomyPartialEvaluatorConfiguration; @@ -105,7 +104,6 @@ public SubstrateTruffleCompiler createTruffleCompiler(SubstrateTruffleRuntime ru protected static TruffleCompilerConfiguration createSubstrateTruffleCompilerConfig(SubstrateTruffleRuntime runtime, String compilerConfigurationName, Method optimizedCallTargetMethod) { RuntimeCompilationFeature runtimeCompilationFeature = RuntimeCompilationFeature.singleton(); - SnippetReflectionProvider snippetReflectionProvider = runtimeCompilationFeature.getHostedProviders().getSnippetReflection(); final GraphBuilderConfiguration.Plugins graphBuilderPlugins = runtimeCompilationFeature.getHostedProviders().getGraphBuilderPlugins(); SubstrateBackend substrateBackend = TruffleRuntimeCompilationSupport.getRuntimeConfig().getBackendForNormalMethod(); substrateBackend.setRuntimeToRuntimeInvokeMethod(optimizedCallTargetMethod); @@ -119,7 +117,8 @@ protected static TruffleCompilerConfiguration createSubstrateTruffleCompilerConf final TruffleTierConfiguration lastTier = new TruffleTierConfiguration(peConfig, substrateBackend, TruffleRuntimeCompilationSupport.getRuntimeConfig().getProviders(), TruffleRuntimeCompilationSupport.getFullOptSuites(), TruffleRuntimeCompilationSupport.getLIRSuites(), types); - return new TruffleCompilerConfiguration(runtime, graphBuilderPlugins, snippetReflectionProvider, firstTier, lastTier, types, TruffleRuntimeCompilationSupport.getFullOptSuites()); + return new TruffleCompilerConfiguration(runtime, graphBuilderPlugins, runtimeCompilationFeature.getHostedProviders().getSnippetReflection(), firstTier, lastTier, types, + TruffleRuntimeCompilationSupport.getFullOptSuites()); } public static boolean isIsolatedCompilation() { diff --git a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/api/SubstrateTruffleCompilerImpl.java b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/api/SubstrateTruffleCompilerImpl.java index f81fb749b0f7..2996bfe6b2fe 100644 --- a/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/api/SubstrateTruffleCompilerImpl.java +++ b/substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/api/SubstrateTruffleCompilerImpl.java @@ -27,6 +27,18 @@ import java.io.PrintStream; import java.util.Map; +import org.graalvm.nativeimage.Platform; +import org.graalvm.nativeimage.Platforms; + +import com.oracle.svm.core.graal.code.SubstrateCompilationResult; +import com.oracle.svm.core.option.RuntimeOptionValues; +import com.oracle.svm.graal.SubstrateGraalUtils; +import com.oracle.svm.graal.TruffleRuntimeCompilationSupport; +import com.oracle.svm.truffle.SubstrateTruffleCompilationIdentifier; +import com.oracle.svm.truffle.TruffleSupport; +import com.oracle.truffle.compiler.TruffleCompilable; +import com.oracle.truffle.compiler.TruffleCompilationTask; + import jdk.graal.compiler.code.CompilationResult; import jdk.graal.compiler.core.CompilationWrapper; import jdk.graal.compiler.core.common.CompilationIdentifier; @@ -44,18 +56,6 @@ import jdk.graal.compiler.truffle.TruffleTierConfiguration; import jdk.graal.compiler.truffle.phases.InstrumentationSuite; import jdk.graal.compiler.truffle.phases.TruffleTier; -import org.graalvm.nativeimage.Platform; -import org.graalvm.nativeimage.Platforms; - -import com.oracle.svm.core.graal.code.SubstrateCompilationResult; -import com.oracle.svm.core.option.RuntimeOptionValues; -import com.oracle.svm.graal.TruffleRuntimeCompilationSupport; -import com.oracle.svm.graal.SubstrateGraalUtils; -import com.oracle.svm.truffle.SubstrateTruffleCompilationIdentifier; -import com.oracle.svm.truffle.TruffleSupport; -import com.oracle.truffle.compiler.TruffleCompilable; -import com.oracle.truffle.compiler.TruffleCompilationTask; - import jdk.vm.ci.code.InstalledCode; public class SubstrateTruffleCompilerImpl extends TruffleCompilerImpl implements SubstrateTruffleCompiler { @@ -82,7 +82,7 @@ public void initialize(TruffleCompilable compilable, boolean firstInitialization @Override protected TruffleTier newTruffleTier(OptionValues options) { return new TruffleTier(options, partialEvaluator, - new InstrumentationSuite(partialEvaluator.instrumentationCfg, config.snippetReflection(), partialEvaluator.getInstrumentation()), + new InstrumentationSuite(partialEvaluator.instrumentationCfg, partialEvaluator.getInstrumentation()), new SubstratePostPartialEvaluationSuite(getGraalOptions(), TruffleCompilerOptions.IterativePartialEscape.getValue(options))); }