How to use

getProviders

method

in

com.oracle.svm.core.graal.meta.RuntimeConfiguration

protected Providers getProviders() {
  return runtimeConfig.getProviders();
}

protected void callForReplacements(DebugContext debug, FeatureHandler featureHandler, @SuppressWarnings("hiding") RuntimeConfiguration runtimeConfig, SnippetReflectionProvider snippetReflection) {
  NativeImageGenerator.registerReplacements(debug, featureHandler, runtimeConfig, runtimeConfig.getProviders(), snippetReflection, true);
}

/**
 * Regular compiled methods. Only entry points and manually marked methods are compiled, all
 * transitively reachable methods are then identified by looking at the callees of already
 * parsed methods.
 */
private void parseAheadOfTimeCompiledMethods() {
  universe.getMethods().stream()
          .filter(method -> method.isEntryPoint() || CompilationInfoSupport.singleton().isForcedCompilation(method))
          .forEach(method -> ensureParsed(method, new EntryPointReason()));
  SubstrateForeignCallsProvider foreignCallsProvider = (SubstrateForeignCallsProvider) runtimeConfig.getProviders().getForeignCalls();
  foreignCallsProvider.getForeignCalls().keySet().stream()
          .map(descriptor -> (HostedMethod) descriptor.findMethod(runtimeConfig.getProviders().getMetaAccess()))
          .filter(method -> method.wrapped.isRootMethod())
          .forEach(method -> ensureParsed(method, new EntryPointReason()));
}

public CompileQueue(DebugContext debug, FeatureHandler featureHandler, HostedUniverse universe, SharedRuntimeConfigurationBuilder runtimeConfigBuilder, Boolean deoptimizeAll,
        SnippetReflectionProvider snippetReflection, ForkJoinPool executorService) {
  this.universe = universe;
  this.compilations = new ConcurrentHashMap<>();
  this.runtimeConfig = runtimeConfigBuilder.getRuntimeConfig();
  this.optimisticOpts = OptimisticOptimizations.ALL.remove(OptimisticOptimizations.Optimization.UseLoopLimitChecks);
  this.deoptimizeAll = deoptimizeAll;
  this.dataCache = new ConcurrentHashMap<>();
  this.executor = new CompletionExecutor(universe.getBigBang(), executorService);
  regularSuites = NativeImageGenerator.createSuites(featureHandler, runtimeConfig, snippetReflection, true);
  deoptTargetSuites = NativeImageGenerator.createSuites(featureHandler, runtimeConfig, snippetReflection, true);
  removeDeoptTargetOptimizations(deoptTargetSuites);
  regularLIRSuites = NativeImageGenerator.createLIRSuites(featureHandler, runtimeConfig.getProviders(), true);
  deoptTargetLIRSuites = NativeImageGenerator.createLIRSuites(featureHandler, runtimeConfig.getProviders(), true);
  removeDeoptTargetOptimizations(deoptTargetLIRSuites);
  // let aotjs override the replacements registration
  callForReplacements(debug, featureHandler, runtimeConfig, snippetReflection);
}

  dest = sConstantFieldProvider;
} else if (source instanceof ForeignCallsProvider) {
  dest = GraalSupport.getRuntimeConfig().getProviders().getForeignCalls();
} else if (source instanceof HostedSnippetReflectionProvider) {
  dest = GraalSupport.getRuntimeConfig().getSnippetReflection();

protected void ensureCompiled(HostedMethod method, CompileReason reason) {
  CompileTask task = new CompileTask(method, reason);
  CompileTask oldTask = compilations.putIfAbsent(method, task);
  if (oldTask != null) {
    // Method is already scheduled for compilation.
    if (oldTask.allReasons != null) {
      oldTask.allReasons.add(reason);
    }
    return;
  }
  if (method.compilationInfo.specializedArguments != null) {
    // Do the specialization: replace the argument locals with the constant arguments.
    StructuredGraph graph = method.compilationInfo.graph;
    int idx = 0;
    for (ConstantNode argument : method.compilationInfo.specializedArguments) {
      ParameterNode local = graph.getParameter(idx++);
      if (local != null) {
        local.replaceAndDelete(ConstantNode.forConstant(argument.asJavaConstant(), runtimeConfig.getProviders().getMetaAccess(), graph));
      }
    }
  }
  executor.execute(task);
  method.setCompiled();
}

public CompileFunction createCustomCompileFunction() {
  return (debug, method, identifier, reason, config) -> {
    SubstrateBackend backend = config.getBackendForNormalMethod();
    VMError.guarantee(backend.getTarget().arch instanceof AMD64, "currently only implemented on AMD64");
    // Determine register for jmethodID argument
    HostedProviders providers = (HostedProviders) config.getProviders();
    List<JavaType> parameters = new ArrayList<>();
    parameters.add(providers.getMetaAccess().lookupJavaType(JNIEnvironment.class));
    parameters.add(providers.getMetaAccess().lookupJavaType(JNIObjectHandle.class));
    if (nonVirtual) {
      parameters.add(providers.getMetaAccess().lookupJavaType(JNIObjectHandle.class));
    }
    parameters.add(providers.getMetaAccess().lookupJavaType(JNIMethodId.class));
    ResolvedJavaType returnType = providers.getWordTypes().getWordImplType();
    CallingConvention callingConvention = backend.getCodeCache().getRegisterConfig().getCallingConvention(
            SubstrateCallingConventionType.NativeCall, returnType, parameters.toArray(new JavaType[0]), backend);
    RegisterValue methodIdArg = (RegisterValue) callingConvention.getArgument(parameters.size() - 1);
    return backend.createJNITrampolineMethod(method, identifier, methodIdArg, getFieldOffset(providers));
  };
}

@Override
public void afterCompilation(AfterCompilationAccess a) {
  CompilationAccessImpl config = (CompilationAccessImpl) a;
  HostedMetaAccess hMetaAccess = config.getMetaAccess();
  HostedUniverse hUniverse = (HostedUniverse) hMetaAccess.getUniverse();
  objectReplacer.updateSubstrateDataAfterCompilation(hUniverse);
  objectReplacer.registerImmutableObjects(config);
  GraalSupport.registerImmutableObjects(config);
  ((SubstrateReplacements) runtimeConfigBuilder.getRuntimeConfig().getProviders().getReplacements()).registerImmutableObjects(config);
}

  @Override
  public void lower(BytecodeExceptionNode node, LoweringTool tool) {
    if (mustNotAllocatePredicate != null && mustNotAllocatePredicate.test(node.graph().method())) {
      RuntimeException exception = cachedExceptions.get(node.getExceptionKind());
      assert exception != null;
      ConstantNode exceptionNode = ConstantNode.forConstant(SubstrateObjectConstant.forObject(exception), tool.getMetaAccess(), node.graph());
      node.graph().replaceFixedWithFloating(node, exceptionNode);
    } else {
      ForeignCallDescriptor descriptor = callDescriptors.get(node.getExceptionKind());
      assert descriptor != null && descriptor.getArgumentTypes().length == node.getArguments().size();
      StructuredGraph graph = node.graph();
      ForeignCallNode foreignCallNode = graph.add(new ForeignCallNode(runtimeConfig.getProviders().getForeignCalls(), descriptor, node.stamp(NodeView.DEFAULT), node.getArguments()));
      foreignCallNode.setStateAfter(node.stateAfter());
      graph.replaceFixedWithFixed(node, foreignCallNode);
    }
  }
}

RuntimeConfiguration runtimeConfig = runtimeConfigBuilder.getRuntimeConfig();
Providers runtimeProviders = runtimeConfig.getProviders();
WordTypes wordTypes = runtimeConfigBuilder.getWordTypes();
hostedProviders = new HostedProviders(runtimeProviders.getMetaAccess(), runtimeProviders.getCodeCache(), runtimeProviders.getConstantReflection(), runtimeProviders.getConstantFieldProvider(),
        config.getImageClassLoader(), false, false);
DebugContext debug = DebugContext.forCurrentThread();
NativeImageGenerator.registerReplacements(debug, featureHandler, runtimeConfig, runtimeConfig.getProviders(), runtimeConfig.getSnippetReflection(), false);
featureHandler.forEachGraalFeature(feature -> feature.registerCodeObserver(runtimeConfig));
Suites suites = NativeImageGenerator.createSuites(featureHandler, runtimeConfig, runtimeConfig.getSnippetReflection(), false);
LIRSuites lirSuites = NativeImageGenerator.createLIRSuites(featureHandler, runtimeConfig.getProviders(), false);
Suites firstTierSuites = NativeImageGenerator.createFirstTierSuites(featureHandler, runtimeConfig, runtimeConfig.getSnippetReflection(), false);
LIRSuites firstTierLirSuites = NativeImageGenerator.createFirstTierLIRSuites(featureHandler, runtimeConfig.getProviders(), false);
GraalSupport.setRuntimeConfig(runtimeConfig, suites, lirSuites, firstTierSuites, firstTierLirSuites);

if (runtimeConfig != null && runtimeConfig.getProviders() instanceof HostedProviders) {
  ((HostedProviders) runtimeConfig.getProviders()).setGraphBuilderPlugins(plugins);
  for (SubstrateBackend backend : runtimeConfig.getBackends()) {
    ((HostedProviders) backend.getProviders()).setGraphBuilderPlugins(plugins);

registerGraphBuilderPlugins(featureHandler, runtime.getRuntimeConfig(), (HostedProviders) runtime.getRuntimeConfig().getProviders(), bigbang.getMetaAccess(), aUniverse,
        hMetaAccess, hUniverse,
        nativeLibraries, loader, false, true);

int vtableEntryOffset = runtimeConfig.getVTableOffset(method.getVTableIndex());
hub = graph.unique(new LoadHubNode(runtimeConfig.getProviders().getStampProvider(), graph.maybeAddOrUnique(PiNode.create(receiver, nullCheck))));
AddressNode address = graph.unique(new OffsetAddressNode(hub, ConstantNode.forIntegerKind(FrameAccess.getWordKind(), vtableEntryOffset, graph)));
ReadNode entry = graph.add(new ReadNode(address, NamedLocationIdentity.FINAL_LOCATION, FrameAccess.getWordStamp(), BarrierType.NONE));