jdk-sandbox: comparison src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotJVMCIRuntime.java

equal deleted inserted replaced

-:f4290bf1cc21
+:f1e6442241ca
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.io.Serializable;
 import java.lang.invoke.CallSite;
 import java.lang.invoke.ConstantCallSite;
 import java.lang.invoke.MethodHandle;
-import java.lang.module.ModuleDescriptor.Requires;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.ServiceLoader;
 import java.util.function.Predicate;
-import jdk.internal.misc.Unsafe;
 import jdk.vm.ci.code.Architecture;
 import jdk.vm.ci.code.CompilationRequestResult;
 import jdk.vm.ci.code.CompiledCode;
 import jdk.vm.ci.code.InstalledCode;
 }
 // Ensures JVMCIRuntime::_HotSpotJVMCIRuntime_instance is
 // initialized.
 JVMCI.getRuntime();
 }
-// Make sure all the primitive box caches are populated (required to properly materialize boxed primitives
+// Make sure all the primitive box caches are populated (required to properly
+// materialize boxed primitives
 // during deoptimization).
-Object[] boxCaches = { Boolean.valueOf(false), Byte.valueOf((byte)0), Short.valueOf((short) 0), Character.valueOf((char) 0), Integer.valueOf(0), Long.valueOf(0) };
+Boolean.valueOf(false);
+Byte.valueOf((byte) 0);
+Short.valueOf((short) 0);
+Character.valueOf((char) 0);
+Integer.valueOf(0);
+Long.valueOf(0);
 }
 }
 return result;
 }
 }
 }
 private static HotSpotJVMCIBackendFactory findFactory(String architecture) {
 Iterable<HotSpotJVMCIBackendFactory> factories = getHotSpotJVMCIBackendFactories();
 assert factories != null : "sanity";
 for (HotSpotJVMCIBackendFactory factory : factories) {
 if (factory.getArchitecture().equalsIgnoreCase(architecture)) {
 return factory;
 }
 }
 * Cache for speeding up {@link #fromClass(Class)}.
 */
 @NativeImageReinitialize private volatile ClassValue<WeakReferenceHolder<HotSpotResolvedJavaType>> resolvedJavaType;
 /**
-* To avoid calling ClassValue.remove to refresh the weak reference, which
+* To avoid calling ClassValue.remove to refresh the weak reference, which under certain
-* under certain circumstances can lead to an infinite loop, we use a
+* circumstances can lead to an infinite loop, we use a permanent holder with a mutable field
-* permanent holder with a mutable field that we refresh.
+* that we refresh.
 */
 private static class WeakReferenceHolder<T> {
 private volatile WeakReference<T> ref;
 WeakReferenceHolder(T value) {
 set(value);
 }
 void set(T value) {
-ref = new WeakReference<T>(value);
+ref = new WeakReference<>(value);
 }
 T get() {
 return ref.get();
 }
-};
+}
 @NativeImageReinitialize private HashMap<Long, WeakReference<ResolvedJavaType>> resolvedJavaTypes;
 /**
-* Stores the value set by {@link #excludeFromJVMCICompilation(Module...)} so that it can
+* Stores the value set by {@link #excludeFromJVMCICompilation(Module...)} so that it can be
-* be read from the VM.
+* read from the VM.
 */
 @SuppressWarnings("unused")//
 @NativeImageReinitialize private Module[] excludeFromJVMCICompilation;
 private final Map<Class<? extends Architecture>, JVMCIBackend> backends = new HashMap<>();
 private volatile List<HotSpotVMEventListener> vmEventListeners;
 private HotSpotResolvedJavaType fromClass0(Class<?> javaClass) {
 if (resolvedJavaType == null) {
 synchronized (this) {
 if (resolvedJavaType == null) {
-resolvedJavaType = new ClassValue<WeakReferenceHolder<HotSpotResolvedJavaType>>() {
+resolvedJavaType = new ClassValue<>() {
 @Override
 protected WeakReferenceHolder<HotSpotResolvedJavaType> computeValue(Class<?> type) {
 return new WeakReferenceHolder<>(createClass(type));
 }
 };
 WeakReferenceHolder<HotSpotResolvedJavaType> ref = resolvedJavaType.get(javaClass);
 HotSpotResolvedJavaType javaType = ref.get();
 if (javaType == null) {
 /*
-* If the referent has become null, create a new value and
+* If the referent has become null, create a new value and update cached weak reference.
-* update cached weak reference.
 */
 javaType = createClass(javaClass);
 ref.set(javaType);
 }
 return javaType;
 *
 * @param compilerLeafClasses classes in the leaves of the module graph comprising the JVMCI
 *            compiler.
 */
 public Predicate<ResolvedJavaType> getIntrinsificationTrustPredicate(Class<?>... compilerLeafClasses) {
-return new Predicate<ResolvedJavaType>() {
+return new Predicate<>() {
 @Override
 public boolean test(ResolvedJavaType type) {
 if (type instanceof HotSpotResolvedObjectTypeImpl) {
 HotSpotResolvedObjectTypeImpl hsType = (HotSpotResolvedObjectTypeImpl) type;
 return compilerToVm.isTrustedForIntrinsics(hsType);

changeset 58851	f1e6442241ca
parent 58793	81ad1da857f6