/*

 * Copyright (c) 2010, 2014, 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.ir.FunctionNode.CompilationState.BUILTINS_TRANSFORMED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.BYTECODE_GENERATED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.BYTECODE_INSTALLED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.CONSTANT_FOLDED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.INITIALIZED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.LOCAL_VARIABLE_TYPES_CALCULATED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.LOWERED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.OPTIMISTIC_TYPES_ASSIGNED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.PARSED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.SCOPE_DEPTHS_COMPUTED;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.SPLIT;

import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.SYMBOLS_ASSIGNED;

import static jdk.nashorn.internal.runtime.logging.DebugLogger.quote;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import jdk.nashorn.internal.AssertsEnabled;

import jdk.nashorn.internal.codegen.Compiler.CompilationPhases;

import jdk.nashorn.internal.ir.FunctionNode;

import jdk.nashorn.internal.ir.FunctionNode.CompilationState;

import jdk.nashorn.internal.ir.LexicalContext;

import jdk.nashorn.internal.ir.LiteralNode;

import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;

import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;

import jdk.nashorn.internal.ir.Node;

import jdk.nashorn.internal.ir.SplitNode;

import jdk.nashorn.internal.ir.debug.ASTWriter;

import jdk.nashorn.internal.ir.debug.PrintVisitor;

import jdk.nashorn.internal.ir.visitor.NodeVisitor;

import jdk.nashorn.internal.runtime.CodeInstaller;

import jdk.nashorn.internal.runtime.FunctionInitializer;

import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData;

import jdk.nashorn.internal.runtime.ScriptEnvironment;

import jdk.nashorn.internal.runtime.logging.DebugLogger;

/**

 * A compilation phase is a step in the processes of turning a JavaScript

 * FunctionNode into bytecode. It has an optional return value.

 */

enum CompilationPhase {

    /**

     * Constant folding pass Simple constant folding that will make elementary

     * constructs go away

     */

    CONSTANT_FOLDING_PHASE(

            EnumSet.of(

                INITIALIZED,

                PARSED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            return (FunctionNode)fn.accept(new FoldConstants(compiler));

        }

        @Override

        public String toString() {

            return "'Constant Folding'";

        }

    },

    /**

     * Lower (Control flow pass) Finalizes the control flow. Clones blocks for

     * finally constructs and similar things. Establishes termination criteria

     * for nodes Guarantee return instructions to method making sure control

     * flow cannot fall off the end. Replacing high level nodes with lower such

     * as runtime nodes where applicable.

     */

    LOWERING_PHASE(

            EnumSet.of(

                INITIALIZED,

                PARSED,

                CONSTANT_FOLDED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            return (FunctionNode)fn.accept(new Lower(compiler));

        }

        @Override

        public String toString() {

            return "'Control Flow Lowering'";

        }

    },

    /**

     * Phase used only when doing optimistic code generation. It assigns all potentially

     * optimistic ops a program point so that an UnwarrantedException knows from where

     * a guess went wrong when creating the continuation to roll back this execution

     */

    PROGRAM_POINT_PHASE(

            EnumSet.of(

                INITIALIZED,

                PARSED,

                CONSTANT_FOLDED,

                LOWERED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            return (FunctionNode)fn.accept(new ProgramPoints());

        }

        @Override

        public String toString() {

            return "'Program Point Calculation'";

        }

    },

    TRANSFORM_BUILTINS_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED)) {

        //we only do this if we have a param type map, otherwise this is not a specialized recompile

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            final FunctionNode newFunctionNode = (FunctionNode)fn.accept(new ApplySpecialization(compiler));

            return (FunctionNode)newFunctionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

                @Override

                public Node leaveFunctionNode(final FunctionNode node) {

                    return node.setState(lc, BUILTINS_TRANSFORMED);

                }

            });

        }

        @Override

        public String toString() {

            return "'Builtin Replacement'";

        }

    },

    /**

     * Splitter Split the AST into several compile units based on a heuristic size calculation.

     * Split IR can lead to scope information being changed.

     */

    SPLITTING_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED,

                    BUILTINS_TRANSFORMED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            final CompileUnit  outermostCompileUnit = compiler.addCompileUnit(0L);

            FunctionNode newFunctionNode;

            //ensure elementTypes, postsets and presets exist for splitter and arraynodes

            newFunctionNode = (FunctionNode)fn.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

                @Override

                public LiteralNode<?> leaveLiteralNode(final LiteralNode<?> literalNode) {

                    return literalNode.initialize(lc);

                }

            });

            newFunctionNode = new Splitter(compiler, newFunctionNode, outermostCompileUnit).split(newFunctionNode, true);

            assert newFunctionNode.getCompileUnit() == outermostCompileUnit : "fn=" + fn.getName() + ", fn.compileUnit (" + newFunctionNode.getCompileUnit() + ") != " + outermostCompileUnit;

            assert newFunctionNode.isStrict() == compiler.isStrict() : "functionNode.isStrict() != compiler.isStrict() for " + quote(newFunctionNode.getName());

            return newFunctionNode;

        }

        @Override

        public String toString() {

            return "'Code Splitting'";

        }

    },

    SYMBOL_ASSIGNMENT_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED,

                    BUILTINS_TRANSFORMED,

                    SPLIT)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            return (FunctionNode)fn.accept(new AssignSymbols(compiler));

        }

        @Override

        public String toString() {

            return "'Symbol Assignment'";

        }

    },

    SCOPE_DEPTH_COMPUTATION_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED,

                    BUILTINS_TRANSFORMED,

                    SPLIT,

                    SYMBOLS_ASSIGNED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            return (FunctionNode)fn.accept(new FindScopeDepths(compiler));

        }

        @Override

        public String toString() {

            return "'Scope Depth Computation'";

        }

    },

    OPTIMISTIC_TYPE_ASSIGNMENT_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED,

                    BUILTINS_TRANSFORMED,

                    SPLIT,

                    SYMBOLS_ASSIGNED,

                    SCOPE_DEPTHS_COMPUTED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            if (compiler.useOptimisticTypes()) {

                return (FunctionNode)fn.accept(new OptimisticTypesCalculator(compiler));

            }

            return setStates(fn, OPTIMISTIC_TYPES_ASSIGNED);

        }

        @Override

        public String toString() {

            return "'Optimistic Type Assignment'";

        }

    },

    LOCAL_VARIABLE_TYPE_CALCULATION_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED,

                    BUILTINS_TRANSFORMED,

                    SPLIT,

                    SYMBOLS_ASSIGNED,

                    SCOPE_DEPTHS_COMPUTED,

                    OPTIMISTIC_TYPES_ASSIGNED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            final FunctionNode newFunctionNode = (FunctionNode)fn.accept(new LocalVariableTypesCalculator(compiler));

            final ScriptEnvironment senv = compiler.getScriptEnvironment();

            final PrintWriter       err  = senv.getErr();

            //TODO separate phase for the debug printouts for abstraction and clarity

            if (senv._print_lower_ast || fn.getFlag(FunctionNode.IS_PRINT_LOWER_AST)) {

                err.println("Lower AST for: " + quote(newFunctionNode.getName()));

                err.println(new ASTWriter(newFunctionNode));

            }

            if (senv._print_lower_parse || fn.getFlag(FunctionNode.IS_PRINT_LOWER_PARSE)) {

                err.println("Lower AST for: " + quote(newFunctionNode.getName()));

                err.println(new PrintVisitor(newFunctionNode));

            }

            return newFunctionNode;

        }

        @Override

        public String toString() {

            return "'Local Variable Type Calculation'";

        }

    },

    /**

     * Reuse compile units, if they are already present. We are using the same compiler

     * to recompile stuff

     */

    REUSE_COMPILE_UNITS_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED,

                    BUILTINS_TRANSFORMED,

                    SPLIT,

                    SYMBOLS_ASSIGNED,

                    SCOPE_DEPTHS_COMPUTED,

                    OPTIMISTIC_TYPES_ASSIGNED,

                    LOCAL_VARIABLE_TYPES_CALCULATED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            assert phases.isRestOfCompilation() : "reuse compile units currently only used for Rest-Of methods";

            final Map<CompileUnit, CompileUnit> map = new HashMap<>();

            final Set<CompileUnit> newUnits = CompileUnit.createCompileUnitSet();

            final DebugLogger log = compiler.getLogger();

            log.fine("Clearing bytecode cache");

            compiler.clearBytecode();

            for (final CompileUnit oldUnit : compiler.getCompileUnits()) {

                assert map.get(oldUnit) == null;

                final StringBuilder sb = new StringBuilder(compiler.nextCompileUnitName());

                if (phases.isRestOfCompilation()) {

                    sb.append("$restOf");

                }

                //it's ok to not copy the initCount, methodCount and clinitCount here, as codegen is what

                //fills those out anyway. Thus no need for a copy constructor

                final CompileUnit newUnit = compiler.createCompileUnit(sb.toString(), oldUnit.getWeight());

                log.fine("Creating new compile unit ", oldUnit, " => ", newUnit);

                map.put(oldUnit, newUnit);

                assert newUnit != null;

                newUnits.add(newUnit);

            }

            log.fine("Replacing compile units in Compiler...");

            compiler.replaceCompileUnits(newUnits);

            log.fine("Done");

            //replace old compile units in function nodes, if any are assigned,

            //for example by running the splitter on this function node in a previous

            //partial code generation

            final FunctionNode newFunctionNode = (FunctionNode)fn.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

                @Override

                public Node leaveFunctionNode(final FunctionNode node) {

                    final CompileUnit oldUnit = node.getCompileUnit();

                    assert oldUnit != null : "no compile unit in function node";

                    final CompileUnit newUnit = map.get(oldUnit);

                    assert newUnit != null : "old unit has no mapping to new unit " + oldUnit;

                    log.fine("Replacing compile unit: ", oldUnit, " => ", newUnit, " in ", quote(node.getName()));

                    return node.setCompileUnit(lc, newUnit).setState(lc, CompilationState.COMPILE_UNITS_REUSED);

                }

                @Override

                public Node leaveSplitNode(final SplitNode node) {

                    final CompileUnit oldUnit = node.getCompileUnit();

                    assert oldUnit != null : "no compile unit in function node";

                    final CompileUnit newUnit = map.get(oldUnit);

                    assert newUnit != null : "old unit has no mapping to new unit " + oldUnit;

                    log.fine("Replacing compile unit: ", oldUnit, " => ", newUnit, " in ", quote(node.getName()));

                    return node.setCompileUnit(lc, newUnit);

                }

                @Override

                public Node leaveLiteralNode(final LiteralNode<?> node) {

                    if (node instanceof ArrayLiteralNode) {

                        final ArrayLiteralNode aln = (ArrayLiteralNode)node;

                        if (aln.getUnits() == null) {

                            return node;

                        }

                        final List<ArrayUnit> newArrayUnits = new ArrayList<>();

                        for (final ArrayUnit au : aln.getUnits()) {

                            final CompileUnit newUnit = map.get(au.getCompileUnit());

                            assert newUnit != null;

                            newArrayUnits.add(new ArrayUnit(newUnit, au.getLo(), au.getHi()));

                        }

                        return aln.setUnits(lc, newArrayUnits);

                    }

                    return node;

                }

                @Override

                public Node leaveDefault(final Node node) {

                    return node.ensureUniqueLabels(lc);

                }

            });

            return newFunctionNode;

        }

        @Override

        public String toString() {

            return "'Reuse Compile Units'";

        }

    },

     /**

     * Bytecode generation:

     *

     * Generate the byte code class(es) resulting from the compiled FunctionNode

     */

    BYTECODE_GENERATION_PHASE(

            EnumSet.of(

                    INITIALIZED,

                    PARSED,

                    CONSTANT_FOLDED,

                    LOWERED,

                    BUILTINS_TRANSFORMED,

                    SPLIT,

                    SYMBOLS_ASSIGNED,

                    SCOPE_DEPTHS_COMPUTED,

                    OPTIMISTIC_TYPES_ASSIGNED,

                    LOCAL_VARIABLE_TYPES_CALCULATED)) {

        @Override

        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {

            final ScriptEnvironment senv = compiler.getScriptEnvironment();

            FunctionNode newFunctionNode = fn;

            //root class is special, as it is bootstrapped from createProgramFunction, thus it's skipped

            //in CodeGeneration - the rest can be used as a working "is compile unit used" metric

            fn.getCompileUnit().setUsed();

            compiler.getLogger().fine("Starting bytecode generation for ", quote(fn.getName()), " - restOf=", phases.isRestOfCompilation());

            final CodeGenerator codegen = new CodeGenerator(compiler, phases.isRestOfCompilation() ? compiler.getContinuationEntryPoints() : null);

            try {

                // Explicitly set BYTECODE_GENERATED here; it can not be set in case of skipping codegen for :program

                // in the lazy + optimistic world. See CodeGenerator.skipFunction().

                newFunctionNode = ((FunctionNode)newFunctionNode.accept(codegen)).setState(null, BYTECODE_GENERATED);

                codegen.generateScopeCalls();

            } catch (final VerifyError e) {

                if (senv._verify_code || senv._print_code) {

                    senv.getErr().println(e.getClass().getSimpleName() + ": "  + e.getMessage());

                    if (senv._dump_on_error) {

                        e.printStackTrace(senv.getErr());

                    }

                } else {

                    throw e;

                }

            } catch (final Throwable e) {

                // Provide source file and line number being compiled when the assertion occurred

                throw new AssertionError("Failed generating bytecode for " + fn.getSourceName() + ":" + codegen.getLastLineNumber(), e);

            }

            for (final CompileUnit compileUnit : compiler.getCompileUnits()) {

                final ClassEmitter classEmitter = compileUnit.getClassEmitter();

                classEmitter.end();

                if (!compileUnit.isUsed()) {

                    compiler.getLogger().fine("Skipping unused compile unit ", compileUnit);

                    continue;

                }

                final byte[] bytecode = classEmitter.toByteArray();

                assert bytecode != null;

                final String className = compileUnit.getUnitClassName();

                compiler.addClass(className, bytecode); //classes are only added to the bytecode map if compile unit is used

                CompileUnit.increaseEmitCount();

                // should we verify the generated code?

                if (senv._verify_code) {

                    compiler.getCodeInstaller().verify(bytecode);

                }

                DumpBytecode.dumpBytecode(senv, compiler.getLogger(), bytecode, className);

            }

            return newFunctionNode;

        }

        @Override

        public String toString() {