jdk8-mips64-public/nashorn: src/jdk/nashorn/internal/codegen/Compiler.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/codegen/Compiler.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/codegen/Compiler.java

Thu, 24 May 2018 16:39:31 +0800

author: aoqi
date: Thu, 24 May 2018 16:39:31 +0800
changeset 1959: 61ffdd1b89f2
parent 1645: b7bbed8b05dd
parent 1490: d85f981c8cf8
permissions: -rw-r--r--

Merge

 /*
  * Copyright (c) 2010, 2013, 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
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package jdk.nashorn.internal.codegen;
 import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS;
 import static jdk.nashorn.internal.codegen.CompilerConstants.CALLEE;
 import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN;
 import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;
 import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
 import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
 import static jdk.nashorn.internal.runtime.logging.DebugLogger.quote;
 import java.io.File;
 import java.lang.invoke.MethodType;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 import java.util.logging.Level;
 import jdk.internal.dynalink.support.NameCodec;
 import jdk.nashorn.internal.codegen.types.Type;
 import jdk.nashorn.internal.ir.Expression;
 import jdk.nashorn.internal.ir.FunctionNode;
 import jdk.nashorn.internal.ir.Optimistic;
 import jdk.nashorn.internal.ir.debug.ClassHistogramElement;
 import jdk.nashorn.internal.ir.debug.ObjectSizeCalculator;
 import jdk.nashorn.internal.runtime.CodeInstaller;
 import jdk.nashorn.internal.runtime.Context;
 import jdk.nashorn.internal.runtime.ErrorManager;
 import jdk.nashorn.internal.runtime.FunctionInitializer;
 import jdk.nashorn.internal.runtime.ParserException;
 import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData;
 import jdk.nashorn.internal.runtime.ScriptEnvironment;
 import jdk.nashorn.internal.runtime.ScriptObject;
 import jdk.nashorn.internal.runtime.ScriptRuntime;
 import jdk.nashorn.internal.runtime.Source;
 import jdk.nashorn.internal.runtime.logging.DebugLogger;
 import jdk.nashorn.internal.runtime.logging.Loggable;
 import jdk.nashorn.internal.runtime.logging.Logger;
 /**
  * Responsible for converting JavaScripts to java byte code. Main entry
  * point for code generator. The compiler may also install classes given some
  * predefined Code installation policy, given to it at construction time.
  * @see CodeInstaller
  */
 @Logger(name="compiler")
 public final class Compiler implements Loggable {
     /** Name of the scripts package */
     public static final String SCRIPTS_PACKAGE = "jdk/nashorn/internal/scripts";
     /** Name of the objects package */
     public static final String OBJECTS_PACKAGE = "jdk/nashorn/internal/objects";
     private final ScriptEnvironment env;
     private final Source source;
     private final String sourceName;
     private final ErrorManager errors;
     private final boolean optimistic;
     private final Map<String, byte[]> bytecode;
     private final Set<CompileUnit> compileUnits;
     private final ConstantData constantData;
     private final CodeInstaller installer;
     /** logger for compiler, trampolines and related code generation events
      *  that affect classes */
     private final DebugLogger log;
     private final Context context;
     private final TypeMap types;
     // Runtime scope in effect at the time of the compilation. Used to evaluate types of expressions and prevent overly
     // optimistic assumptions (which will lead to unnecessary deoptimizing recompilations).
     private final TypeEvaluator typeEvaluator;
     private final boolean strict;
     private final boolean onDemand;
     /**
      * If this is a recompilation, this is how we pass in the invalidations, e.g. programPoint=17, Type == int means
      * that using whatever was at program point 17 as an int failed.
      */
     private final Map<Integer, Type> invalidatedProgramPoints;
     /**
      * Descriptor of the location where we write the type information after compilation.
      */
     private final Object typeInformationFile;
     /**
      * Compile unit name of first compile unit - this prefix will be used for all
      * classes that a compilation generates.
      */
     private final String firstCompileUnitName;
     /**
      * Contains the program point that should be used as the continuation entry point, as well as all previous
      * continuation entry points executed as part of a single logical invocation of the function. In practical terms, if
      * we execute a rest-of method from the program point 17, but then we hit deoptimization again during it at program
      * point 42, and execute a rest-of method from the program point 42, and then we hit deoptimization again at program
      * point 57 and are compiling a rest-of method for it, the values in the array will be [57, 42, 17]. This is only
      * set when compiling a rest-of method. If this method is a rest-of for a non-rest-of method, the array will have
      * one element. If it is a rest-of for a rest-of, the array will have two elements, and so on.
      */
     private final int[] continuationEntryPoints;
     /**
      * ScriptFunction data for what is being compile, where applicable.
      * TODO: make this immutable, propagate it through the CompilationPhases
      */
     private RecompilableScriptFunctionData compiledFunction;
     /**
      * Most compile unit names are longer than the default StringBuilder buffer,
      * worth startup performance when massive class generation is going on to increase
      * this
      */
     private static final int COMPILE_UNIT_NAME_BUFFER_SIZE = 32;
     /**
      * Compilation phases that a compilation goes through
      */
     public static class CompilationPhases implements Iterable<CompilationPhase> {
         /**
          * Singleton that describes compilation up to the phase where a function can be cached.
          */
         private final static CompilationPhases COMPILE_UPTO_CACHED = new CompilationPhases(
                 "Common initial phases",
                 CompilationPhase.CONSTANT_FOLDING_PHASE,
                 CompilationPhase.LOWERING_PHASE,
                 CompilationPhase.APPLY_SPECIALIZATION_PHASE,
                 CompilationPhase.SPLITTING_PHASE,
                 CompilationPhase.PROGRAM_POINT_PHASE,
                 CompilationPhase.SYMBOL_ASSIGNMENT_PHASE,
                 CompilationPhase.SCOPE_DEPTH_COMPUTATION_PHASE,
                 CompilationPhase.CACHE_AST_PHASE
                 );
         private final static CompilationPhases COMPILE_CACHED_UPTO_BYTECODE = new CompilationPhases(
                 "After common phases, before bytecode generator",
                 CompilationPhase.OPTIMISTIC_TYPE_ASSIGNMENT_PHASE,
                 CompilationPhase.LOCAL_VARIABLE_TYPE_CALCULATION_PHASE
                 );
         /**
          * Singleton that describes additional steps to be taken after retrieving a cached function, all the
          * way up to (but not including) generating and installing code.
          */
         public final static CompilationPhases RECOMPILE_CACHED_UPTO_BYTECODE = new CompilationPhases(
                 "Recompile cached function up to bytecode",
                 CompilationPhase.REINITIALIZE_CACHED,
                 COMPILE_CACHED_UPTO_BYTECODE
                 );
         /**
          * Singleton that describes back end of method generation, given that we have generated the normal
          * method up to CodeGenerator as in {@link CompilationPhases#COMPILE_UPTO_BYTECODE}
          */
         public final static CompilationPhases GENERATE_BYTECODE_AND_INSTALL = new CompilationPhases(
                 "Generate bytecode and install",
                 CompilationPhase.BYTECODE_GENERATION_PHASE,
                 CompilationPhase.INSTALL_PHASE
                 );
         /** Singleton that describes compilation up to the CodeGenerator, but not actually generating code */
         public final static CompilationPhases COMPILE_UPTO_BYTECODE = new CompilationPhases(
                 "Compile upto bytecode",
                 COMPILE_UPTO_CACHED,
                 COMPILE_CACHED_UPTO_BYTECODE);
         /** Singleton that describes a standard eager compilation, but no installation, for example used by --compile-only */
         public final static CompilationPhases COMPILE_ALL_NO_INSTALL = new CompilationPhases(
                 "Compile without install",
                 COMPILE_UPTO_BYTECODE,
                 CompilationPhase.BYTECODE_GENERATION_PHASE);
         /** Singleton that describes a standard eager compilation - this includes code installation */
         public final static CompilationPhases COMPILE_ALL = new CompilationPhases(
                 "Full eager compilation",
                 COMPILE_UPTO_BYTECODE,
                 GENERATE_BYTECODE_AND_INSTALL);
         /** Singleton that describes a full compilation - this includes code installation - from serialized state*/
         public final static CompilationPhases COMPILE_ALL_CACHED = new CompilationPhases(
                 "Eager compilation from serializaed state",
                 RECOMPILE_CACHED_UPTO_BYTECODE,
                 GENERATE_BYTECODE_AND_INSTALL);
         /**
          * Singleton that describes restOf method generation, given that we have generated the normal
          * method up to CodeGenerator as in {@link CompilationPhases#COMPILE_UPTO_BYTECODE}
          */
         public final static CompilationPhases GENERATE_BYTECODE_AND_INSTALL_RESTOF = new CompilationPhases(
                 "Generate bytecode and install - RestOf method",
                 CompilationPhase.REUSE_COMPILE_UNITS_PHASE,
                 GENERATE_BYTECODE_AND_INSTALL);
         /** Compile all for a rest of method */
         public final static CompilationPhases COMPILE_ALL_RESTOF = new CompilationPhases(
                 "Compile all, rest of",
                 COMPILE_UPTO_BYTECODE,
                 GENERATE_BYTECODE_AND_INSTALL_RESTOF);
         /** Compile from serialized for a rest of method */
         public final static CompilationPhases COMPILE_CACHED_RESTOF = new CompilationPhases(
                 "Compile serialized, rest of",
                 RECOMPILE_CACHED_UPTO_BYTECODE,
                 GENERATE_BYTECODE_AND_INSTALL_RESTOF);
         private final List<CompilationPhase> phases;
         private final String desc;
         private CompilationPhases(final String desc, final CompilationPhase... phases) {
             this(desc, Arrays.asList(phases));
         }
         private CompilationPhases(final String desc, final CompilationPhases base, final CompilationPhase... phases) {
             this(desc, concat(base.phases, Arrays.asList(phases)));
         }
         private CompilationPhases(final String desc, final CompilationPhase first, final CompilationPhases rest) {
             this(desc, concat(Collections.singletonList(first), rest.phases));
         }
         private CompilationPhases(final String desc, final CompilationPhases base) {
             this(desc, base.phases);
         }
         private CompilationPhases(final String desc, final CompilationPhases... bases) {
             this(desc, concatPhases(bases));
         }
         private CompilationPhases(final String desc, final List<CompilationPhase> phases) {
             this.desc = desc;
             this.phases = phases;
         }
         private static List<CompilationPhase> concatPhases(final CompilationPhases[] bases) {
             final ArrayList<CompilationPhase> l = new ArrayList<>();
             for(final CompilationPhases base: bases) {
                 l.addAll(base.phases);
             }
             l.trimToSize();
             return l;
         }
         private static <T> List<T> concat(final List<T> l1, final List<T> l2) {
             final ArrayList<T> l = new ArrayList<>(l1);
             l.addAll(l2);
             l.trimToSize();
             return l;
         }
         @Override
         public String toString() {
             return "'" + desc + "' " + phases.toString();
         }
         boolean contains(final CompilationPhase phase) {
             return phases.contains(phase);
         }
         @Override
         public Iterator<CompilationPhase> iterator() {
             return phases.iterator();
         }
         boolean isRestOfCompilation() {
             return this == COMPILE_ALL_RESTOF || this == GENERATE_BYTECODE_AND_INSTALL_RESTOF || this == COMPILE_CACHED_RESTOF;
         }
         String getDesc() {
             return desc;
         }
         String toString(final String prefix) {
             final StringBuilder sb = new StringBuilder();
             for (final CompilationPhase phase : phases) {
                 sb.append(prefix).append(phase).append('\n');
             }
             return sb.toString();
         }
     }
     /**
      * This array contains names that need to be reserved at the start
      * of a compile, to avoid conflict with variable names later introduced.
      * See {@link CompilerConstants} for special names used for structures
      * during a compile.
      */
     private static String[] RESERVED_NAMES = {
         SCOPE.symbolName(),
         THIS.symbolName(),
         RETURN.symbolName(),
         CALLEE.symbolName(),
         VARARGS.symbolName(),
         ARGUMENTS.symbolName()
     };
     // per instance
     private final int compilationId = COMPILATION_ID.getAndIncrement();
     // per instance
     private final AtomicInteger nextCompileUnitId = new AtomicInteger(0);
     private static final AtomicInteger COMPILATION_ID = new AtomicInteger(0);
     /**
      * Creates a new compiler instance for initial compilation of a script.
      *
      * @param installer code installer
      * @param source    source to compile
      * @param errors    error manager
      * @param isStrict  is this a strict compilation
      * @return a new compiler
      */
     public static Compiler forInitialCompilation(
             final CodeInstaller installer,
             final Source source,
             final ErrorManager errors,
             final boolean isStrict) {
         return new Compiler(installer.getContext(), installer, source, errors, isStrict);
     }
     /**
      * Creates a compiler without a code installer. It can only be used to compile code, not install the
      * generated classes and as such it is useful only for implementation of {@code --compile-only} command
      * line option.
      * @param context  the current context
      * @param source   source to compile
      * @param isStrict is this a strict compilation
      * @return a new compiler
      */
     public static Compiler forNoInstallerCompilation(
             final Context context,
             final Source source,
             final boolean isStrict) {
         return new Compiler(context, null, source, context.getErrorManager(), isStrict);
     }
     /**
      * Creates a compiler for an on-demand compilation job.
      *
      * @param installer                code installer
      * @param source                   source to compile
      * @param isStrict                 is this a strict compilation
      * @param compiledFunction         compiled function, if any
      * @param types                    parameter and return value type information, if any is known
      * @param invalidatedProgramPoints invalidated program points for recompilation
      * @param typeInformationFile      descriptor of the location where type information is persisted
      * @param continuationEntryPoints  continuation entry points for restof method
      * @param runtimeScope             runtime scope for recompilation type lookup in {@code TypeEvaluator}
      * @return a new compiler
      */
     public static Compiler forOnDemandCompilation(
             final CodeInstaller installer,
             final Source source,
             final boolean isStrict,
             final RecompilableScriptFunctionData compiledFunction,
             final TypeMap types,
             final Map<Integer, Type> invalidatedProgramPoints,
             final Object typeInformationFile,
             final int[] continuationEntryPoints,
             final ScriptObject runtimeScope) {
         final Context context = installer.getContext();
         return new Compiler(context, installer, source, context.getErrorManager(), isStrict, true,
                 compiledFunction, types, invalidatedProgramPoints, typeInformationFile,
                 continuationEntryPoints, runtimeScope);
     }
     /**
      * Convenience constructor for non on-demand compiler instances.
      */
     private Compiler(
             final Context context,
             final CodeInstaller installer,
             final Source source,
             final ErrorManager errors,
             final boolean isStrict) {
         this(context, installer, source, errors, isStrict, false, null, null, null, null, null, null);
     }
     private Compiler(
             final Context context,
             final CodeInstaller installer,
             final Source source,
             final ErrorManager errors,
             final boolean isStrict,
             final boolean isOnDemand,
             final RecompilableScriptFunctionData compiledFunction,
             final TypeMap types,
             final Map<Integer, Type> invalidatedProgramPoints,
             final Object typeInformationFile,
             final int[] continuationEntryPoints,
             final ScriptObject runtimeScope) {
         this.context                  = context;
         this.env                      = context.getEnv();
         this.installer                = installer;
         this.constantData             = new ConstantData();
         this.compileUnits             = CompileUnit.createCompileUnitSet();
         this.bytecode                 = new LinkedHashMap<>();
         this.log                      = initLogger(context);
         this.source                   = source;
         this.errors                   = errors;
         this.sourceName               = FunctionNode.getSourceName(source);
         this.onDemand                 = isOnDemand;
         this.compiledFunction         = compiledFunction;
         this.types                    = types;
         this.invalidatedProgramPoints = invalidatedProgramPoints == null ? new HashMap<Integer, Type>() : invalidatedProgramPoints;
         this.typeInformationFile      = typeInformationFile;
         this.continuationEntryPoints  = continuationEntryPoints == null ? null: continuationEntryPoints.clone();
         this.typeEvaluator            = new TypeEvaluator(this, runtimeScope);
         this.firstCompileUnitName     = firstCompileUnitName();
         this.strict                   = isStrict;
         this.optimistic = env._optimistic_types;
     }
     private String safeSourceName() {
         String baseName = new File(source.getName()).getName();
         final int index = baseName.lastIndexOf(".js");
         if (index != -1) {
             baseName = baseName.substring(0, index);
         }
         baseName = baseName.replace('.', '_').replace('-', '_');
         if (!env._loader_per_compile) {
             baseName = baseName + installer.getUniqueScriptId();
         }
         // ASM's bytecode verifier does not allow JVM allowed safe escapes using '\' as escape char.
         // While ASM accepts such escapes for method names, field names, it enforces Java identifier
         // for class names. Workaround that ASM bug here by replacing JVM 'dangerous' chars with '_'
         // rather than safe encoding using '\'.
         final String mangled = env._verify_code? replaceDangerChars(baseName) : NameCodec.encode(baseName);
         return mangled != null ? mangled : baseName;
     }
     private static final String DANGEROUS_CHARS   = "\\/.;:$[]<>";
     private static String replaceDangerChars(final String name) {
         final int len = name.length();
         final StringBuilder buf = new StringBuilder();
         for (int i = 0; i < len; i++) {
             final char ch = name.charAt(i);
             if (DANGEROUS_CHARS.indexOf(ch) != -1) {
                 buf.append('_');
             } else {
                 buf.append(ch);
             }
         }
         return buf.toString();
     }
     private String firstCompileUnitName() {
         final StringBuilder sb = new StringBuilder(SCRIPTS_PACKAGE).
                 append('/').
                 append(CompilerConstants.DEFAULT_SCRIPT_NAME.symbolName()).
                 append('$');
         if (isOnDemandCompilation()) {
             sb.append(RecompilableScriptFunctionData.RECOMPILATION_PREFIX);
         }
         if (compilationId > 0) {
             sb.append(compilationId).append('$');
         }
         if (types != null && compiledFunction.getFunctionNodeId() > 0) {
             sb.append(compiledFunction.getFunctionNodeId());
             final Type[] paramTypes = types.getParameterTypes(compiledFunction.getFunctionNodeId());
             for (final Type t : paramTypes) {
                 sb.append(Type.getShortSignatureDescriptor(t));
             }
             sb.append('$');
         }
         sb.append(safeSourceName());
         return sb.toString();
     }
     void declareLocalSymbol(final String symbolName) {
         typeEvaluator.declareLocalSymbol(symbolName);
     }
     void setData(final RecompilableScriptFunctionData data) {
         assert this.compiledFunction == null : data;
         this.compiledFunction = data;
     }
     @Override
     public DebugLogger getLogger() {
         return log;
     }
     @Override
     public DebugLogger initLogger(final Context ctxt) {
         final boolean optimisticTypes = env._optimistic_types;
         final boolean lazyCompilation = env._lazy_compilation;
         return ctxt.getLogger(this.getClass(), new Consumer<DebugLogger>() {
             @Override
             public void accept(final DebugLogger newLogger) {
                 if (!lazyCompilation) {
                     newLogger.warning("WARNING: Running with lazy compilation switched off. This is not a default setting.");
                 }
                 newLogger.warning("Optimistic types are ", optimisticTypes ? "ENABLED." : "DISABLED.");
             }
         });
     }
     ScriptEnvironment getScriptEnvironment() {
         return env;
     }
     boolean isOnDemandCompilation() {
         return onDemand;
     }
     boolean useOptimisticTypes() {
         return optimistic;
     }
     Context getContext() {
         return context;
     }
     Type getOptimisticType(final Optimistic node) {
         return typeEvaluator.getOptimisticType(node);
     }
     /**
      * Returns true if the expression can be safely evaluated, and its value is an object known to always use
      * String as the type of its property names retrieved through
      * {@link ScriptRuntime#toPropertyIterator(Object)}. It is used to avoid optimistic assumptions about its
      * property name types.
      * @param expr the expression to test
      * @return true if the expression can be safely evaluated, and its value is an object known to always use
      * String as the type of its property iterators.
      */
     boolean hasStringPropertyIterator(final Expression expr) {
         return typeEvaluator.hasStringPropertyIterator(expr);
     }
     void addInvalidatedProgramPoint(final int programPoint, final Type type) {
         invalidatedProgramPoints.put(programPoint, type);
     }
     /**
      * Returns a copy of this compiler's current mapping of invalidated optimistic program points to their types. The
      * copy is not live with regard to changes in state in this compiler instance, and is mutable.
      * @return a copy of this compiler's current mapping of invalidated optimistic program points to their types.
      */
     public Map<Integer, Type> getInvalidatedProgramPoints() {
         return invalidatedProgramPoints.isEmpty() ? null : new TreeMap<>(invalidatedProgramPoints);
     }
     TypeMap getTypeMap() {
         return types;
     }
     MethodType getCallSiteType(final FunctionNode fn) {
         if (types == null || !isOnDemandCompilation()) {
             return null;
         }
         return types.getCallSiteType(fn);
     }
     Type getParamType(final FunctionNode fn, final int pos) {
         return types == null ? null : types.get(fn, pos);
     }
     /**
      * Do a compilation job
      *
      * @param functionNode function node to compile
      * @param phases phases of compilation transforms to apply to function
      * @return transformed function
      *
      * @throws CompilationException if error occurs during compilation
      */
     public FunctionNode compile(final FunctionNode functionNode, final CompilationPhases phases) throws CompilationException {
         if (log.isEnabled()) {
             log.info(">> Starting compile job for ", DebugLogger.quote(functionNode.getName()), " phases=", quote(phases.getDesc()));
             log.indent();
         }
         final String name = DebugLogger.quote(functionNode.getName());
         FunctionNode newFunctionNode = functionNode;
         for (final String reservedName : RESERVED_NAMES) {
             newFunctionNode.uniqueName(reservedName);
         }
         final boolean info = log.isLoggable(Level.INFO);
         final DebugLogger timeLogger = env.isTimingEnabled() ? env._timing.getLogger() : null;
         long time = 0L;
         for (final CompilationPhase phase : phases) {
             log.fine(phase, " starting for ", name);
             try {
                 newFunctionNode = phase.apply(this, phases, newFunctionNode);
             } catch (final ParserException error) {
                 errors.error(error);
                 if (env._dump_on_error) {
                     error.printStackTrace(env.getErr());
                 }
                 return null;
             }
             log.fine(phase, " done for function ", quote(name));
             if (env._print_mem_usage) {
                 printMemoryUsage(functionNode, phase.toString());
             }
             time += (env.isTimingEnabled() ? phase.getEndTime() - phase.getStartTime() : 0L);
         }
         if (typeInformationFile != null && !phases.isRestOfCompilation()) {
             OptimisticTypesPersistence.store(typeInformationFile, invalidatedProgramPoints);
         }
         log.unindent();
         if (info) {
             final StringBuilder sb = new StringBuilder("<< Finished compile job for ");
             sb.append(newFunctionNode.getSource()).
             append(':').
             append(quote(newFunctionNode.getName()));
             if (time > 0L && timeLogger != null) {
                 assert env.isTimingEnabled();
                 sb.append(" in ").append(TimeUnit.NANOSECONDS.toMillis(time)).append(" ms");
             }
             log.info(sb);
         }
         return newFunctionNode;
     }
     Source getSource() {
         return source;
     }
     Map<String, byte[]> getBytecode() {
         return Collections.unmodifiableMap(bytecode);
     }
     /**
      * Reset bytecode cache for compiler reuse.
      */
     void clearBytecode() {
         bytecode.clear();
     }
     CompileUnit getFirstCompileUnit() {
         assert !compileUnits.isEmpty();
         return compileUnits.iterator().next();
     }
     Set<CompileUnit> getCompileUnits() {
         return compileUnits;
     }
     ConstantData getConstantData() {
         return constantData;
     }
     CodeInstaller getCodeInstaller() {
         return installer;
     }
     void addClass(final String name, final byte[] code) {
         bytecode.put(name, code);
     }
     String nextCompileUnitName() {
         final StringBuilder sb = new StringBuilder(COMPILE_UNIT_NAME_BUFFER_SIZE);
         sb.append(firstCompileUnitName);
         final int cuid = nextCompileUnitId.getAndIncrement();
         if (cuid > 0) {
             sb.append("$cu").append(cuid);
         }
         return sb.toString();
     }
     /**
      * Persist current compilation with the given {@code cacheKey}.
      * @param cacheKey cache key
      * @param functionNode function node
      */
     public void persistClassInfo(final String cacheKey, final FunctionNode functionNode) {
         if (cacheKey != null && env._persistent_cache) {
             // If this is an on-demand compilation create a function initializer for the function being compiled.
             // Otherwise use function initializer map generated by codegen.
             final Map<Integer, FunctionInitializer> initializers = new HashMap<>();
             if (isOnDemandCompilation()) {
                 initializers.put(functionNode.getId(), new FunctionInitializer(functionNode, getInvalidatedProgramPoints()));
             } else {
                 for (final CompileUnit compileUnit : getCompileUnits()) {
                     for (final FunctionNode fn : compileUnit.getFunctionNodes()) {
                         initializers.put(fn.getId(), new FunctionInitializer(fn));
                     }
                 }
             }
             final String mainClassName = getFirstCompileUnit().getUnitClassName();
             installer.storeScript(cacheKey, source, mainClassName, bytecode, initializers, constantData.toArray(), compilationId);
         }
     }
     /**
      * Make sure the next compilation id is greater than {@code value}.
      * @param value compilation id value
      */
     public static void updateCompilationId(final int value) {
         if (value >= COMPILATION_ID.get()) {
             COMPILATION_ID.set(value + 1);
         }
     }
     CompileUnit addCompileUnit(final long initialWeight) {
         final CompileUnit compileUnit = createCompileUnit(initialWeight);
         compileUnits.add(compileUnit);
         log.fine("Added compile unit ", compileUnit);
         return compileUnit;
     }
     CompileUnit createCompileUnit(final String unitClassName, final long initialWeight) {
         final ClassEmitter classEmitter = new ClassEmitter(context, sourceName, unitClassName, isStrict());
         final CompileUnit  compileUnit  = new CompileUnit(unitClassName, classEmitter, initialWeight);
         classEmitter.begin();
         return compileUnit;
     }
     private CompileUnit createCompileUnit(final long initialWeight) {
         return createCompileUnit(nextCompileUnitName(), initialWeight);
     }
     boolean isStrict() {
         return strict;
     }
     void replaceCompileUnits(final Set<CompileUnit> newUnits) {
         compileUnits.clear();
         compileUnits.addAll(newUnits);
     }
     CompileUnit findUnit(final long weight) {
         for (final CompileUnit unit : compileUnits) {
             if (unit.canHold(weight)) {
                 unit.addWeight(weight);
                 return unit;
             }
         }
         return addCompileUnit(weight);
     }
     /**
      * Convert a package/class name to a binary name.
      *
      * @param name Package/class name.
      * @return Binary name.
      */
     public static String binaryName(final String name) {
         return name.replace('/', '.');
     }
     RecompilableScriptFunctionData getScriptFunctionData(final int functionId) {
         assert compiledFunction != null;
         final RecompilableScriptFunctionData fn = compiledFunction.getScriptFunctionData(functionId);
         assert fn != null : functionId;
         return fn;
     }
     boolean isGlobalSymbol(final FunctionNode fn, final String name) {
         return getScriptFunctionData(fn.getId()).isGlobalSymbol(fn, name);
     }
     int[] getContinuationEntryPoints() {
         return continuationEntryPoints;
     }
     Type getInvalidatedProgramPointType(final int programPoint) {
         return invalidatedProgramPoints.get(programPoint);
     }
     private void printMemoryUsage(final FunctionNode functionNode, final String phaseName) {
         if (!log.isEnabled()) {
             return;
         }
         log.info(phaseName, "finished. Doing IR size calculation...");
         final ObjectSizeCalculator osc = new ObjectSizeCalculator(ObjectSizeCalculator.getEffectiveMemoryLayoutSpecification());
         osc.calculateObjectSize(functionNode);
         final List<ClassHistogramElement> list      = osc.getClassHistogram();
         final StringBuilder               sb        = new StringBuilder();
         final long                        totalSize = osc.calculateObjectSize(functionNode);
         sb.append(phaseName).
         append(" Total size = ").
         append(totalSize / 1024 / 1024).
         append("MB");
         log.info(sb);
         Collections.sort(list, new Comparator<ClassHistogramElement>() {
             @Override
             public int compare(final ClassHistogramElement o1, final ClassHistogramElement o2) {
                 final long diff = o1.getBytes() - o2.getBytes();
                 if (diff < 0) {
                     return 1;
                 } else if (diff > 0) {
                     return -1;
                 } else {
                     return 0;
                 }
             }
         });
         for (final ClassHistogramElement e : list) {
             final String line = String.format("    %-48s %10d bytes (%8d instances)", e.getClazz(), e.getBytes(), e.getInstances());
             log.info(line);
             if (e.getBytes() < totalSize / 200) {
                 log.info("    ...");
                 break; // never mind, so little memory anyway
             }
         }
     }
 }

Mercurial > jdk8-mips64-public > nashorn / annotate

src/jdk/nashorn/internal/codegen/Compiler.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/codegen/Compiler.java