--- a/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.services/src/jdk/vm/ci/services/Services.java Wed May 01 12:41:26 2019 -0400
+++ b/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.services/src/jdk/vm/ci/services/Services.java Wed May 01 12:31:29 2019 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -22,10 +22,23 @@
*/
package jdk.vm.ci.services;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Formatter;
+import java.util.HashMap;
+import java.util.List;
import java.util.Map;
+import java.util.Properties;
+import java.util.ServiceLoader;
import java.util.Set;
import jdk.internal.misc.VM;
+import jdk.internal.reflect.Reflection;
/**
* Provides utilities needed by JVMCI clients.
@@ -36,35 +49,32 @@
// processors while building JDK 9 so use of API added in JDK 9 is made via reflection.
/**
- * Guards code that should be run when building a native image but should be excluded from
- * (being compiled into) the image. Such code must be directly guarded by an {@code if}
+ * Guards code that should be run when building an JVMCI shared library but should be excluded
+ * from (being compiled into) the library. Such code must be directly guarded by an {@code if}
* statement on this field - the guard cannot be behind a method call.
*/
- public static final boolean IS_BUILDING_NATIVE_IMAGE;
+ public static final boolean IS_BUILDING_NATIVE_IMAGE = Boolean.parseBoolean(VM.getSavedProperty("jdk.vm.ci.services.aot"));
/**
- * Guards code that should only be run in native image. Such code must be directly guarded by an
- * {@code if} statement on this field - the guard cannot be behind a method call.
+ * Guards code that should only be run in a JVMCI shared library. Such code must be directly
+ * guarded by an {@code if} statement on this field - the guard cannot be behind a method call.
*
- * The value of this field seen during analysis and compilation of an SVM image must be
- * {@code true}.
+ * The value of this field in a JVMCI shared library runtime must be {@code true}.
*/
public static final boolean IS_IN_NATIVE_IMAGE;
-
static {
/*
- * Prevents javac from constant folding use of this field. It is set to true in the SVM
- * image via substitution during image building.
+ * Prevents javac from constant folding use of this field. It is set to true by the process
+ * that builds the shared library.
*/
IS_IN_NATIVE_IMAGE = false;
- IS_BUILDING_NATIVE_IMAGE = false;
}
private Services() {
}
- static final Map<String, String> SAVED_PROPERTIES = VM.getSavedProperties();
- static final boolean JVMCI_ENABLED = Boolean.parseBoolean(SAVED_PROPERTIES.get("jdk.internal.vm.ci.enabled"));
+ private static volatile Map<String, String> savedProperties = VM.getSavedProperties();
+ static final boolean JVMCI_ENABLED = Boolean.parseBoolean(savedProperties.get("jdk.internal.vm.ci.enabled"));
/**
* Checks that JVMCI is enabled in the VM and throws an error if it isn't.
@@ -84,7 +94,21 @@
if (sm != null) {
sm.checkPermission(new JVMCIPermission());
}
- return SAVED_PROPERTIES;
+ return savedProperties;
+ }
+
+ /**
+ * Helper method equivalent to {@link #getSavedProperties()}{@code .getOrDefault(name, def)}.
+ */
+ public static String getSavedProperty(String name, String def) {
+ return Services.getSavedProperties().getOrDefault(name, def);
+ }
+
+ /**
+ * Helper method equivalent to {@link #getSavedProperties()}{@code .get(name)}.
+ */
+ public static String getSavedProperty(String name) {
+ return Services.getSavedProperties().get(name);
}
/**
@@ -99,6 +123,83 @@
}
}
+ private static boolean jvmciEnabled = true;
+
+ /**
+ * When {@code -XX:-UseJVMCIClassLoader} is in use, JVMCI classes are loaded via the boot class
+ * loader. When {@code null} is the second argument to
+ * {@link ServiceLoader#load(Class, ClassLoader)}, service lookup will use the system class
+ * loader and thus find application classes which violates the API of {@link #load} and
+ * {@link #loadSingle}. To avoid this, a class loader that simply delegates to the boot class
+ * loader is used.
+ */
+ static class LazyBootClassPath {
+ static final ClassLoader bootClassPath = new ClassLoader(null) {
+ };
+ }
+
+ private static ClassLoader findBootClassLoaderChild(ClassLoader start) {
+ ClassLoader cl = start;
+ while (cl.getParent() != null) {
+ cl = cl.getParent();
+ }
+ return cl;
+ }
+
+ private static final Map<Class<?>, List<?>> servicesCache = IS_BUILDING_NATIVE_IMAGE ? new HashMap<>() : null;
+
+ @SuppressWarnings("unchecked")
+ private static <S> Iterable<S> load0(Class<S> service) {
+ if (IS_IN_NATIVE_IMAGE || IS_BUILDING_NATIVE_IMAGE) {
+ List<?> list = servicesCache.get(service);
+ if (list != null) {
+ return (Iterable<S>) list;
+ }
+ if (IS_IN_NATIVE_IMAGE) {
+ throw new InternalError(String.format("No %s providers found when building native image", service.getName()));
+ }
+ }
+
+ Iterable<S> providers = Collections.emptyList();
+ if (jvmciEnabled) {
+ ClassLoader cl = null;
+ try {
+ cl = getJVMCIClassLoader();
+ if (cl == null) {
+ cl = LazyBootClassPath.bootClassPath;
+ // JVMCI classes are loaded via the boot class loader.
+ // If we use null as the second argument to ServiceLoader.load,
+ // service loading will use the system class loader
+ // and find classes on the application class path. Since we
+ // don't want this, we use a loader that is as close to the
+ // boot class loader as possible (since it is impossible
+ // to force service loading to use only the boot class loader).
+ cl = findBootClassLoaderChild(ClassLoader.getSystemClassLoader());
+ }
+ providers = ServiceLoader.load(service, cl);
+ } catch (UnsatisfiedLinkError e) {
+ jvmciEnabled = false;
+ } catch (InternalError e) {
+ if (e.getMessage().equals("JVMCI is not enabled")) {
+ jvmciEnabled = false;
+ } else {
+ throw e;
+ }
+ }
+ }
+ if (IS_BUILDING_NATIVE_IMAGE) {
+ synchronized (servicesCache) {
+ ArrayList<S> providersList = new ArrayList<>();
+ for (S provider : providers) {
+ providersList.add(provider);
+ }
+ servicesCache.put(service, providersList);
+ providers = providersList;
+ }
+ }
+ return providers;
+ }
+
/**
* Opens all JVMCI packages to {@code otherModule}.
*/
@@ -114,4 +215,123 @@
}
}
}
+
+ /**
+ * Gets an {@link Iterable} of the JVMCI providers available for a given service.
+ *
+ * @throws SecurityException if a security manager is present and it denies <tt>
+ * {@link RuntimePermission}("jvmci")</tt>
+ */
+ public static <S> Iterable<S> load(Class<S> service) {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkPermission(new JVMCIPermission());
+ }
+ return load0(service);
+ }
+
+ /**
+ * Gets the JVMCI provider for a given service for which at most one provider must be available.
+ *
+ * @param service the service whose provider is being requested
+ * @param required specifies if an {@link InternalError} should be thrown if no provider of
+ * {@code service} is available
+ * @throws SecurityException if a security manager is present and it denies <tt>
+ * {@link RuntimePermission}("jvmci")</tt>
+ */
+ public static <S> S loadSingle(Class<S> service, boolean required) {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkPermission(new JVMCIPermission());
+ }
+ Iterable<S> providers = load0(service);
+
+ S singleProvider = null;
+ for (S provider : providers) {
+ if (singleProvider != null) {
+ throw new InternalError(String.format("Multiple %s providers found: %s, %s", service.getName(), singleProvider.getClass().getName(), provider.getClass().getName()));
+ }
+ singleProvider = provider;
+ }
+ if (singleProvider == null && required) {
+ String javaHome = Services.getSavedProperty("java.home");
+ String vmName = Services.getSavedProperty("java.vm.name");
+ Formatter errorMessage = new Formatter();
+ errorMessage.format("The VM does not expose required service %s.%n", service.getName());
+ errorMessage.format("Currently used Java home directory is %s.%n", javaHome);
+ errorMessage.format("Currently used VM configuration is: %s", vmName);
+ throw new UnsupportedOperationException(errorMessage.toString());
+ }
+ return singleProvider;
+ }
+
+ static {
+ Reflection.registerMethodsToFilter(Services.class, Set.of("getJVMCIClassLoader"));
+ }
+
+ /**
+ * Gets the JVMCI class loader.
+ *
+ * @throws InternalError with the {@linkplain Throwable#getMessage() message}
+ * {@code "JVMCI is not enabled"} iff JVMCI is not enabled
+ */
+ private static ClassLoader getJVMCIClassLoader() {
+ if (IS_IN_NATIVE_IMAGE) {
+ return null;
+ }
+ return ClassLoader.getSystemClassLoader();
+ }
+
+ /**
+ * Serializes the {@linkplain #getSavedProperties() saved system properties} to a byte array for
+ * the purpose of {@linkplain #initializeSavedProperties(byte[]) initializing} the initial
+ * properties in the JVMCI shared library.
+ */
+ @VMEntryPoint
+ private static byte[] serializeSavedProperties() throws IOException {
+ if (IS_IN_NATIVE_IMAGE) {
+ throw new InternalError("Can only serialize saved properties in HotSpot runtime");
+ }
+ Map<String, String> props = Services.getSavedProperties();
+
+ // Compute size of output on the assumption that
+ // all system properties have ASCII names and values
+ int estimate = 4;
+ for (Map.Entry<String, String> e : props.entrySet()) {
+ String name = e.getKey();
+ String value = e.getValue();
+ estimate += (2 + (name.length())) + (2 + (value.length()));
+ }
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream(estimate);
+ DataOutputStream out = new DataOutputStream(baos);
+ out.writeInt(props.size());
+ for (Map.Entry<String, String> e : props.entrySet()) {
+ String name = e.getKey();
+ String value = e.getValue();
+ out.writeUTF(name);
+ out.writeUTF(value);
+ }
+ return baos.toByteArray();
+ }
+
+ /**
+ * Initialized the {@linkplain #getSavedProperties() saved system properties} in the JVMCI
+ * shared library from the {@linkplain #serializeSavedProperties() serialized saved properties}
+ * in the HotSpot runtime.
+ */
+ @VMEntryPoint
+ private static void initializeSavedProperties(byte[] serializedProperties) throws IOException {
+ if (!IS_IN_NATIVE_IMAGE) {
+ throw new InternalError("Can only initialize saved properties in JVMCI shared library runtime");
+ }
+ DataInputStream in = new DataInputStream(new ByteArrayInputStream(serializedProperties));
+ Map<String, String> props = new HashMap<>(in.readInt());
+ while (in.available() != 0) {
+ String name = in.readUTF();
+ String value = in.readUTF();
+ props.put(name, value);
+ }
+ savedProperties = Collections.unmodifiableMap(props);
+ }
}