jdk-sandbox: comparison nashorn/src/jdk/nashorn/internal/runtime/Context.java

equal deleted inserted replaced

-:a3ef17770bab
+:7c0614b75e23
 * questions.
 */
 package jdk.nashorn.internal.runtime;
+import static jdk.nashorn.internal.codegen.CompilerConstants.CONSTANTS;
 import static jdk.nashorn.internal.codegen.CompilerConstants.RUN_SCRIPT;
+import static jdk.nashorn.internal.codegen.CompilerConstants.SOURCE;
 import static jdk.nashorn.internal.codegen.CompilerConstants.STRICT_MODE;
 import static jdk.nashorn.internal.lookup.Lookup.MH;
 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
 import java.io.PrintWriter;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.SoftReference;
+import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.security.AccessControlContext;
 import java.security.AccessController;
 import java.security.CodeSigner;
 import java.security.CodeSource;
 import java.security.Permissions;
 import java.security.PrivilegedAction;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
 import java.security.ProtectionDomain;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
 import jdk.internal.org.objectweb.asm.ClassReader;
 import jdk.internal.org.objectweb.asm.util.CheckClassAdapter;
 public ScriptEnvironment getOwner() {
 return context.env;
 }
 @Override
-public Class<?> install(final String className, final byte[] bytecode) {
+public Class<?> install(final String className, final byte[] bytecode, final Source source, final Object[] constants) {
-return loader.installClass(className, bytecode, codeSource);
+Compiler.LOG.fine("Installing class ", className);
+final String   binaryName = Compiler.binaryName(className);
+final Class<?> clazz      = loader.installClass(binaryName, bytecode, codeSource);
+try {
+// Need doPrivileged because these fields are private
+AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
+@Override
+public Void run() throws Exception {
+//use reflection to write source and constants table to installed classes
+final Field sourceField    = clazz.getDeclaredField(SOURCE.symbolName());
+final Field constantsField = clazz.getDeclaredField(CONSTANTS.symbolName());
+sourceField.setAccessible(true);
+constantsField.setAccessible(true);
+sourceField.set(null, source);
+constantsField.set(null, constants);
+return null;
+}
+});
+} catch (final PrivilegedActionException e) {
+throw new RuntimeException(e);
+}
+return clazz;
 }
 @Override
 public void verify(final byte[] code) {
 context.verify(code);
 @Override
 public long getUniqueEvalId() {
 return context.getUniqueEvalId();
 }
+@Override
+public void storeCompiledScript(final Source source, final String mainClassName,
+final Map<String, byte[]> classBytes, final Object[] constants) {
+if (context.codeStore != null) {
+try {
+context.codeStore.putScript(source, mainClassName, classBytes, constants);
+} catch (final IOException e) {
+throw new RuntimeException(e);
+}
+}
+}
 }
 /** Is Context global debug mode enabled ? */
 public static final boolean DEBUG = Options.getBooleanProperty("nashorn.debug");
 private static final ThreadLocal<Global> currentGlobal = new ThreadLocal<>();
-// class cache
+// in-memory cache for loaded classes
 private ClassCache classCache;
+// persistent code store
+private CodeStore codeStore;
 /**
 * Get the current global scope
 * @return the current global scope
 */
 }
 final int cacheSize = env._class_cache_size;
 if (cacheSize > 0) {
 classCache = new ClassCache(cacheSize);
+}
+if (env._persistent_cache) {
+if (env._lazy_compilation || env._specialize_calls != null) {
+getErr().println("Can not use persistent class caching with lazy compilation or call specialization.");
+} else {
+try {
+final String cacheDir = Options.getStringProperty("nashorn.persistent.code.cache", "nashorn_code_cache");
+codeStore = new CodeStore(cacheDir);
+} catch (IOException e) {
+throw new RuntimeException("Error initializing code cache", e);
+}
+}
 }
 // print version info if asked.
 if (env._version) {
 getErr().println("nashorn " + Version.version());
 if (script != null) {
 Compiler.LOG.fine("Code cache hit for ", source, " avoiding recompile.");
 return script;
 }
-final FunctionNode functionNode = new Parser(env, source, errMan, strict).parse();
+CompiledScript compiledScript = null;
-if (errors.hasErrors()) {
+FunctionNode functionNode = null;
-return null;
-}
+if (!env._parse_only && codeStore != null) {
+try {
-if (env._print_ast) {
+compiledScript = codeStore.getScript(source);
-getErr().println(new ASTWriter(functionNode));
+} catch (IOException | ClassNotFoundException e) {
-}
+Compiler.LOG.warning("Error loading ", source, " from cache: ", e);
+// Fall back to normal compilation
-if (env._print_parse) {
+}
-getErr().println(new PrintVisitor(functionNode));
+}
+if (compiledScript == null) {
+functionNode = new Parser(env, source, errMan, strict).parse();
+if (errors.hasErrors()) {
+return null;
+}
+if (env._print_ast) {
+getErr().println(new ASTWriter(functionNode));
+}
+if (env._print_parse) {
+getErr().println(new PrintVisitor(functionNode));
+}
 }
 if (env._parse_only) {
 return null;
 }
 final URL          url    = source.getURL();
 final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
 final CodeSource   cs     = new CodeSource(url, (CodeSigner[])null);
 final CodeInstaller<ScriptEnvironment> installer = new ContextCodeInstaller(this, loader, cs);
-final Compiler compiler = new Compiler(installer, strict);
+if (functionNode != null) {
+final Compiler compiler = new Compiler(installer, strict);
 final FunctionNode newFunctionNode = compiler.compile(functionNode);
 script = compiler.install(newFunctionNode);
+} else {
+script = install(compiledScript, installer);
+}
 cacheClass(source, script);
 return script;
 }
 private ScriptLoader createNewLoader() {
 return AccessController.doPrivileged(
 private long getUniqueScriptId() {
 return uniqueScriptId.getAndIncrement();
 }
+/**
+* Install a previously compiled class from the code cache.
+*
+* @param compiledScript cached script containing class bytes and constants
+* @return main script class
+*/
+private Class<?> install(final CompiledScript compiledScript, final CodeInstaller<ScriptEnvironment> installer) {
+final Map<String, Class<?>> installedClasses = new HashMap<>();
+final Source   source        = compiledScript.getSource();
+final Object[] constants     = compiledScript.getConstants();
+final String   rootClassName = compiledScript.getMainClassName();
+final byte[]   rootByteCode  = compiledScript.getClassBytes().get(rootClassName);
+final Class<?> rootClass     = installer.install(rootClassName, rootByteCode, source, constants);
+installedClasses.put(rootClassName, rootClass);
+for (final Map.Entry<String, byte[]> entry : compiledScript.getClassBytes().entrySet()) {
+final String className = entry.getKey();
+if (className.equals(rootClassName)) {
+continue;
+}
+final byte[] code = entry.getValue();
+installedClasses.put(className, installer.install(className, code, source, constants));
+}
+for (Object constant : constants) {
+if (constant instanceof RecompilableScriptFunctionData) {
+((RecompilableScriptFunctionData) constant).setCodeAndSource(installedClasses, source);
+}
+}
+return rootClass;
+}
 /**
 * Cache for compiled script classes.
 */
 @SuppressWarnings("serial")
 private static class ClassCache extends LinkedHashMap<Source, ClassReference> {

changeset 23767	7c0614b75e23
parent 23375	a1110f2cbe75
child 24206	40c6d45af73f