private static native void registerNatives();

static {

runtimeSetup();

}

@AOTRuntimeSetup

private static void runtimeSetup() {

registerNatives();

}

// The parent class loader for delegation

// Note: VM hardcoded the offset of this field, thus all new fields

// must be added *after* it.

private final ClassLoader parent;

// class loader name

private final String name;

// the unnamed module for this ClassLoader

private final Module unnamedModule;

// a string for exception message printing

private final String nameAndId;

/**

private static class ParallelLoaders {

private ParallelLoaders() {}

// the set of parallel capable loader types

private static final Set<Class<? extends ClassLoader>> loaderTypes =

Collections.newSetFromMap(new WeakHashMap<>());

static {

synchronized (loaderTypes) { loaderTypes.add(ClassLoader.class); }

}

/**

static boolean register(Class<? extends ClassLoader> c) {

synchronized (loaderTypes) {

if (loaderTypes.contains(c.getSuperclass())) {

// register the class loader as parallel capable

// if and only if all of its super classes are.

// Note: given current classloading sequence, if

// the immediate super class is parallel capable,

// all the super classes higher up must be too.

loaderTypes.add(c);

return true;

} else {

return false;

}

}

}

/**

static boolean isRegistered(Class<? extends ClassLoader> c) {

synchronized (loaderTypes) {

return loaderTypes.contains(c);

}

}

}

// Maps class name to the corresponding lock object when the current

// class loader is parallel capable.

// Note: VM also uses this field to decide if the current class loader

// is parallel capable and the appropriate lock object for class loading.

private final ConcurrentHashMap<String, Object> parallelLockMap;

// Maps packages to certs

private final ConcurrentHashMap<String, Certificate[]> package2certs;

// Shared among all packages with unsigned classes

private static final Certificate[] nocerts = new Certificate[0];

// The "default" domain. Set as the default ProtectionDomain on newly

// created classes.

private final ProtectionDomain defaultDomain =

new ProtectionDomain(new CodeSource(null, (Certificate[]) null),

null, this, null);

// The packages defined in this class loader. Each package name is

// mapped to its corresponding NamedPackage object.

//

// The value is a Package object if ClassLoader::definePackage,

// Class::getPackage, ClassLoader::getDefinePackage(s) or

// Package::getPackage(s) method is called to define it.

// Otherwise, the value is a NamedPackage object.

private final ConcurrentHashMap<String, NamedPackage> packages

= new ConcurrentHashMap<>();

/*

private NamedPackage getNamedPackage(String pn, Module m) {

NamedPackage p = packages.get(pn);

if (p == null) {

p = new NamedPackage(pn, m);

NamedPackage value = packages.putIfAbsent(pn, p);

if (value != null) {

// Package object already be defined for the named package

p = value;

// if definePackage is called by this class loader to define

// a package in a named module, this will return Package

// object of the same name. Package object may contain

// unexpected information but it does not impact the runtime.

// this assertion may be helpful for troubleshooting

assert value.module() == m;

}

}

return p;

}

private static Void checkCreateClassLoader() {

return checkCreateClassLoader(null);

}

private static Void checkCreateClassLoader(String name) {

if (name != null && name.isEmpty()) {

throw new IllegalArgumentException("name must be non-empty or null");

}

return null;

}

private ClassLoader(Void unused, String name, ClassLoader parent) {

this.name = name;

this.parent = parent;

this.unnamedModule = new Module(this);

if (ParallelLoaders.isRegistered(this.getClass())) {

parallelLockMap = new ConcurrentHashMap<>();

assertionLock = new Object();

} else {

// no finer-grained lock; lock on the classloader instance

parallelLockMap = null;

assertionLock = this;

}

this.package2certs = new ConcurrentHashMap<>();

this.nameAndId = nameAndId(this);

}

/**

private static String nameAndId(ClassLoader ld) {

String nid = ld.getName() != null ? "\'" + ld.getName() + "\'"

: ld.getClass().getName();

if (!(ld instanceof BuiltinClassLoader)) {

String id = Integer.toHexString(System.identityHashCode(ld));

nid = nid + " @" + id;

}

return nid;

}

// Returns nameAndId string for exception message printing

String nameAndId() {

return nameAndId;

}

/**

@SuppressWarnings("this-escape")

protected ClassLoader(String name, ClassLoader parent) {

this(checkCreateClassLoader(name), name, parent);

}

/**

@SuppressWarnings("this-escape")

protected ClassLoader(ClassLoader parent) {

this(checkCreateClassLoader(), null, parent);

}

/**

@SuppressWarnings("this-escape")

protected ClassLoader() {

this(checkCreateClassLoader(), null, getSystemClassLoader());

}

/**

public String getName() {

return name;

}

// package-private used by StackTraceElement to avoid

// calling the overridable getName method

final String name() {

return name;

}

// -- Class --

/**

public Class<?> loadClass(String name) throws ClassNotFoundException {

return loadClass(name, false);

}

/**

protected Class<?> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

synchronized (getClassLoadingLock(name)) {

// First, check if the class has already been loaded

Class<?> c = findLoadedClass(name);

if (c == null) {

long t0 = System.nanoTime();

try {

if (parent != null) {

c = parent.loadClass(name, false);

} else {

c = findBootstrapClassOrNull(name);

}

} catch (ClassNotFoundException e) {

// ClassNotFoundException thrown if class not found

// from the non-null parent class loader

}

if (c == null) {

// If still not found, then invoke findClass in order

// to find the class.

long t1 = System.nanoTime();

c = findClass(name);

// this is the defining class loader; record the stats

PerfCounter.getParentDelegationTime().addTime(t1 - t0);

PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

PerfCounter.getFindClasses().increment();

}

}

if (resolve) {

resolveClass(c);

}

return c;

}

}

/**

final Class<?> loadClass(Module module, String name) {

synchronized (getClassLoadingLock(name)) {

// First, check if the class has already been loaded

Class<?> c = findLoadedClass(name);

if (c == null) {

c = findClass(module.getName(), name);

}

if (c != null && c.getModule() == module) {

return c;

} else {

return null;

}

}

}

/**

protected Object getClassLoadingLock(String className) {

Object lock = this;

if (parallelLockMap != null) {

Object newLock = new Object();

lock = parallelLockMap.putIfAbsent(className, newLock);

if (lock == null) {

lock = newLock;

}

}

return lock;

}

/**

protected Class<?> findClass(String name) throws ClassNotFoundException {

throw new ClassNotFoundException(name);

}

/**

protected Class<?> findClass(String moduleName, String name) {

if (moduleName == null) {

try {

return findClass(name);

} catch (ClassNotFoundException ignore) { }

}

return null;

}

/**

@Deprecated(since="1.1")

protected final Class<?> defineClass(byte[] b, int off, int len)

throws ClassFormatError

{

return defineClass(null, b, off, len, null);

}

/**

protected final Class<?> defineClass(String name, byte[] b, int off, int len)

throws ClassFormatError

{

return defineClass(name, b, off, len, null);

}

/* Determine protection domain, and check that:

private ProtectionDomain preDefineClass(String name,

ProtectionDomain pd)

{

if (!checkName(name))

throw new NoClassDefFoundError("IllegalName: " + name);

// Note: Checking logic in java.lang.invoke.MemberName.checkForTypeAlias

// relies on the fact that spoofing is impossible if a class has a name

// of the form "java.*"

if ((name != null) && name.startsWith("java.")

&& this != getBuiltinPlatformClassLoader()) {

throw new SecurityException

("Prohibited package name: " +

name.substring(0, name.lastIndexOf('.')));

}

if (pd == null) {

pd = defaultDomain;

}

if (name != null) {

checkCerts(name, pd.getCodeSource());

}

return pd;

}

private String defineClassSourceLocation(ProtectionDomain pd) {

CodeSource cs = pd.getCodeSource();

String source = null;

if (cs != null && cs.getLocation() != null) {

source = cs.getLocation().toString();

}

return source;

}

private void postDefineClass(Class<?> c, ProtectionDomain pd) {

// define a named package, if not present

getNamedPackage(c.getPackageName(), c.getModule());

if (pd.getCodeSource() != null) {

Certificate certs[] = pd.getCodeSource().getCertificates();

if (certs != null)

setSigners(c, certs);

}

}

/**

protected final Class<?> defineClass(String name, byte[] b, int off, int len,

ProtectionDomain protectionDomain)

throws ClassFormatError

{

protectionDomain = preDefineClass(name, protectionDomain);

String source = defineClassSourceLocation(protectionDomain);

Class<?> c = defineClass1(this, name, b, off, len, protectionDomain, source);

postDefineClass(c, protectionDomain);

return c;

}

/**