/*

 * 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.ClassEmitter.Flag.PRIVATE;

import static jdk.nashorn.internal.codegen.ClassEmitter.Flag.STATIC;

import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS;

import static jdk.nashorn.internal.codegen.CompilerConstants.CALLEE;

import static jdk.nashorn.internal.codegen.CompilerConstants.GET_MAP;

import static jdk.nashorn.internal.codegen.CompilerConstants.GET_STRING;

import static jdk.nashorn.internal.codegen.CompilerConstants.QUICK_PREFIX;

import static jdk.nashorn.internal.codegen.CompilerConstants.REGEX_PREFIX;

import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN;

import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;

import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_ARRAY_ARG;

import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_PREFIX;

import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;

import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;

import static jdk.nashorn.internal.codegen.CompilerConstants.constructorNoLookup;

import static jdk.nashorn.internal.codegen.CompilerConstants.interfaceCallNoLookup;

import static jdk.nashorn.internal.codegen.CompilerConstants.methodDescriptor;

import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;

import static jdk.nashorn.internal.codegen.CompilerConstants.staticField;

import static jdk.nashorn.internal.codegen.CompilerConstants.typeDescriptor;

import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL;

import static jdk.nashorn.internal.ir.Symbol.IS_TEMP;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_FAST_SCOPE;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_SCOPE;

import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_STRICT;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.TreeMap;

import jdk.nashorn.internal.codegen.ClassEmitter.Flag;

import jdk.nashorn.internal.codegen.CompilerConstants.Call;

import jdk.nashorn.internal.codegen.RuntimeCallSite.SpecializedRuntimeNode;

import jdk.nashorn.internal.codegen.types.ArrayType;

import jdk.nashorn.internal.codegen.types.Type;

import jdk.nashorn.internal.ir.AccessNode;

import jdk.nashorn.internal.ir.BaseNode;

import jdk.nashorn.internal.ir.BinaryNode;

import jdk.nashorn.internal.ir.Block;

import jdk.nashorn.internal.ir.BreakNode;

import jdk.nashorn.internal.ir.BreakableNode;

import jdk.nashorn.internal.ir.CallNode;

import jdk.nashorn.internal.ir.CaseNode;

import jdk.nashorn.internal.ir.CatchNode;

import jdk.nashorn.internal.ir.ContinueNode;

import jdk.nashorn.internal.ir.EmptyNode;

import jdk.nashorn.internal.ir.ExecuteNode;

import jdk.nashorn.internal.ir.ForNode;

import jdk.nashorn.internal.ir.FunctionNode;

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

import jdk.nashorn.internal.ir.IdentNode;

import jdk.nashorn.internal.ir.IfNode;

import jdk.nashorn.internal.ir.IndexNode;

import jdk.nashorn.internal.ir.LexicalContext;

import jdk.nashorn.internal.ir.LexicalContextNode;

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.LoopNode;

import jdk.nashorn.internal.ir.Node;

import jdk.nashorn.internal.ir.ObjectNode;

import jdk.nashorn.internal.ir.PropertyNode;

import jdk.nashorn.internal.ir.ReturnNode;

import jdk.nashorn.internal.ir.RuntimeNode;

import jdk.nashorn.internal.ir.RuntimeNode.Request;

import jdk.nashorn.internal.ir.SplitNode;

import jdk.nashorn.internal.ir.Statement;

import jdk.nashorn.internal.ir.SwitchNode;

import jdk.nashorn.internal.ir.Symbol;

import jdk.nashorn.internal.ir.TernaryNode;

import jdk.nashorn.internal.ir.ThrowNode;

import jdk.nashorn.internal.ir.TryNode;

import jdk.nashorn.internal.ir.UnaryNode;

import jdk.nashorn.internal.ir.VarNode;

import jdk.nashorn.internal.ir.WhileNode;

import jdk.nashorn.internal.ir.WithNode;

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

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

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

import jdk.nashorn.internal.parser.Lexer.RegexToken;

import jdk.nashorn.internal.parser.TokenType;

import jdk.nashorn.internal.runtime.Context;

import jdk.nashorn.internal.runtime.Debug;

import jdk.nashorn.internal.runtime.DebugLogger;

import jdk.nashorn.internal.runtime.ECMAException;

import jdk.nashorn.internal.runtime.JSType;

import jdk.nashorn.internal.runtime.Property;

import jdk.nashorn.internal.runtime.PropertyMap;

import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData;

import jdk.nashorn.internal.runtime.Scope;

import jdk.nashorn.internal.runtime.ScriptFunction;

import jdk.nashorn.internal.runtime.ScriptObject;

import jdk.nashorn.internal.runtime.ScriptRuntime;

import jdk.nashorn.internal.runtime.Source;

import jdk.nashorn.internal.runtime.Undefined;

import jdk.nashorn.internal.runtime.linker.LinkerCallSite;

/**

 * This is the lowest tier of the code generator. It takes lowered ASTs emitted

 * from Lower and emits Java byte code. The byte code emission logic is broken

 * out into MethodEmitter. MethodEmitter works internally with a type stack, and

 * keeps track of the contents of the byte code stack. This way we avoid a large

 * number of special cases on the form

 * <pre>

 * if (type == INT) {

 *     visitInsn(ILOAD, slot);

 * } else if (type == DOUBLE) {

 *     visitInsn(DOUBLE, slot);

 * }

 * </pre>

 * This quickly became apparent when the code generator was generalized to work

 * with all types, and not just numbers or objects.

 * <p>

 * The CodeGenerator visits nodes only once, tags them as resolved and emits

 * bytecode for them.

 */

final class CodeGenerator extends NodeOperatorVisitor<CodeGeneratorLexicalContext> {

    /** Name of the Global object, cannot be referred to as .class, @see CodeGenerator */

    private static final String GLOBAL_OBJECT = Compiler.OBJECTS_PACKAGE + '/' + "Global";

    /** Name of the ScriptFunctionImpl, cannot be referred to as .class @see FunctionObjectCreator */

    private static final String SCRIPTFUNCTION_IMPL_OBJECT = Compiler.OBJECTS_PACKAGE + '/' + "ScriptFunctionImpl";

    /** Constant data & installation. The only reason the compiler keeps this is because it is assigned

     *  by reflection in class installation */

    private final Compiler compiler;

    /** Call site flags given to the code generator to be used for all generated call sites */

    private final int callSiteFlags;

    /** How many regexp fields have been emitted */

    private int regexFieldCount;

    /** Line number for last statement. If we encounter a new line number, line number bytecode information

     *  needs to be generated */

    private int lastLineNumber = -1;

    /** When should we stop caching regexp expressions in fields to limit bytecode size? */

    private static final int MAX_REGEX_FIELDS = 2 * 1024;

    /** Current method emitter */

    private MethodEmitter method;

    /** Current compile unit */

    private CompileUnit unit;

    private static final DebugLogger LOG   = new DebugLogger("codegen", "nashorn.codegen.debug");

    /**

     * Constructor.

     *

     * @param compiler

     */

    CodeGenerator(final Compiler compiler) {

        super(new CodeGeneratorLexicalContext());

        this.compiler      = compiler;

        this.callSiteFlags = compiler.getEnv()._callsite_flags;

    }

    /**

     * Gets the call site flags, adding the strict flag if the current function

     * being generated is in strict mode

     *

     * @return the correct flags for a call site in the current function

     */

    int getCallSiteFlags() {

        return lc.getCurrentFunction().isStrict() ? callSiteFlags | CALLSITE_STRICT : callSiteFlags;

    }

    /**

     * Load an identity node

     *

     * @param identNode an identity node to load

     * @return the method generator used

     */

    private MethodEmitter loadIdent(final IdentNode identNode) {

        final Symbol symbol = identNode.getSymbol();

        if (!symbol.isScope()) {

            assert symbol.hasSlot() || symbol.isParam();

            return method.load(symbol);

        }

        final String name   = symbol.getName();

        final Source source = lc.getCurrentFunction().getSource();

        if (CompilerConstants.__FILE__.name().equals(name)) {

            return method.load(source.getName());

        } else if (CompilerConstants.__DIR__.name().equals(name)) {

            return method.load(source.getBase());

        } else if (CompilerConstants.__LINE__.name().equals(name)) {

            return method.load(source.getLine(identNode.position())).convert(Type.OBJECT);

        } else {

            assert identNode.getSymbol().isScope() : identNode + " is not in scope!";

            final int flags = CALLSITE_SCOPE | getCallSiteFlags();

            method.loadCompilerConstant(SCOPE);

            if (isFastScope(symbol)) {

                // Only generate shared scope getter for fast-scope symbols so we know we can dial in correct scope.

                if (symbol.getUseCount() > SharedScopeCall.FAST_SCOPE_GET_THRESHOLD) {

                    return loadSharedScopeVar(identNode.getType(), symbol, flags);

                }

                return loadFastScopeVar(identNode.getType(), symbol, flags, identNode.isFunction());

            }

            return method.dynamicGet(identNode.getType(), identNode.getName(), flags, identNode.isFunction());

        }

    }

    /**

     * Check if this symbol can be accessed directly with a putfield or getfield or dynamic load

     *

     * @param function function to check for fast scope

     * @return true if fast scope

     */

    private boolean isFastScope(final Symbol symbol) {

        if (!symbol.isScope()) {

            return false;

        }

        if (!lc.inDynamicScope()) {

            // If there's no with or eval in context, and the symbol is marked as scoped, it is fast scoped. Such a

            // symbol must either be global, or its defining block must need scope.

            assert symbol.isGlobal() || lc.getDefiningBlock(symbol).needsScope() : symbol.getName();

            return true;

        }

        if (symbol.isGlobal()) {

            // Shortcut: if there's a with or eval in context, globals can't be fast scoped

            return false;

        }

        // Otherwise, check if there's a dynamic scope between use of the symbol and its definition

        final String name = symbol.getName();

        boolean previousWasBlock = false;

        for (final Iterator<LexicalContextNode> it = lc.getAllNodes(); it.hasNext();) {

            final LexicalContextNode node = it.next();

            if (node instanceof Block) {

                // If this block defines the symbol, then we can fast scope the symbol.

                final Block block = (Block)node;

                if (block.getExistingSymbol(name) == symbol) {

                    assert block.needsScope();

                    return true;

                }

                previousWasBlock = true;

            } else {

                if ((node instanceof WithNode && previousWasBlock) || (node instanceof FunctionNode && CodeGeneratorLexicalContext.isFunctionDynamicScope((FunctionNode)node))) {

                    // If we hit a scope that can have symbols introduced into it at run time before finding the defining

                    // block, the symbol can't be fast scoped. A WithNode only counts if we've immediately seen a block

                    // before - its block. Otherwise, we are currently processing the WithNode's expression, and that's

                    // obviously not subjected to introducing new symbols.

                    return false;

                }

                previousWasBlock = false;

            }

        }

        // Should've found the symbol defined in a block

        throw new AssertionError();

    }

    private MethodEmitter loadSharedScopeVar(final Type valueType, final Symbol symbol, final int flags) {

        method.load(isFastScope(symbol) ? getScopeProtoDepth(lc.getCurrentBlock(), symbol) : -1);

        final SharedScopeCall scopeCall = lc.getScopeGet(unit, valueType, symbol, flags | CALLSITE_FAST_SCOPE);

        return scopeCall.generateInvoke(method);

    }

    private MethodEmitter loadFastScopeVar(final Type valueType, final Symbol symbol, final int flags, final boolean isMethod) {

        loadFastScopeProto(symbol, false);

        return method.dynamicGet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE, isMethod);

    }

    private MethodEmitter storeFastScopeVar(final Type valueType, final Symbol symbol, final int flags) {

        loadFastScopeProto(symbol, true);

        method.dynamicSet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE);

        return method;

    }

    private int getScopeProtoDepth(final Block startingBlock, final Symbol symbol) {

        int depth = 0;

        final String name = symbol.getName();

        for(final Iterator<Block> blocks = lc.getBlocks(startingBlock); blocks.hasNext();) {

            final Block currentBlock = blocks.next();

            if (currentBlock.getExistingSymbol(name) == symbol) {

                return depth;

            }

            if (currentBlock.needsScope()) {

                ++depth;

            }

        }

        return -1;

    }

    private void loadFastScopeProto(final Symbol symbol, final boolean swap) {

        final int depth = getScopeProtoDepth(lc.getCurrentBlock(), symbol);

        assert depth != -1;

        if (depth > 0) {

            if (swap) {

                method.swap();

            }

            for (int i = 0; i < depth; i++) {

                method.invoke(ScriptObject.GET_PROTO);

            }

            if (swap) {

                method.swap();

            }

        }

    }

    /**

     * Generate code that loads this node to the stack. This method is only

     * public to be accessible from the maps sub package. Do not call externally

     *

     * @param node node to load

     *

     * @return the method emitter used

     */

    MethodEmitter load(final Node node) {

        return load(node, false);

    }

    private MethodEmitter load(final Node node, final boolean baseAlreadyOnStack) {

        final Symbol symbol = node.getSymbol();

        // If we lack symbols, we just generate what we see.

        if (symbol == null) {

            node.accept(this);

            return method;

        }

        /*

         * The load may be of type IdentNode, e.g. "x", AccessNode, e.g. "x.y"

         * or IndexNode e.g. "x[y]". Both AccessNodes and IndexNodes are

         * BaseNodes and the logic for loading the base object is reused

         */

        final CodeGenerator codegen = this;

        node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

            @Override

            public boolean enterIdentNode(final IdentNode identNode) {

                loadIdent(identNode);

                return false;

            }

            @Override

            public boolean enterAccessNode(final AccessNode accessNode) {

                if (!baseAlreadyOnStack) {

                    load(accessNode.getBase()).convert(Type.OBJECT);

                }

                assert method.peekType().isObject();

                method.dynamicGet(node.getType(), accessNode.getProperty().getName(), getCallSiteFlags(), accessNode.isFunction());

                return false;

            }

            @Override

            public boolean enterIndexNode(final IndexNode indexNode) {

                if (!baseAlreadyOnStack) {

                    load(indexNode.getBase()).convert(Type.OBJECT);

                    load(indexNode.getIndex());

                }

                method.dynamicGetIndex(node.getType(), getCallSiteFlags(), indexNode.isFunction());

                return false;

            }

            @Override

            public boolean enterFunctionNode(FunctionNode functionNode) {

                // function nodes will always leave a constructed function object on stack, no need to load the symbol

                // separately as in enterDefault()

                functionNode.accept(codegen);

                return false;

            }

            @Override

            public boolean enterDefault(final Node otherNode) {

                otherNode.accept(codegen); // generate code for whatever we are looking at.

                method.load(symbol); // load the final symbol to the stack (or nop if no slot, then result is already there)

                return false;

            }

        });

        return method;

    }

    @Override

    public boolean enterAccessNode(final AccessNode accessNode) {

        load(accessNode);

        return false;

    }

    /**

     * Initialize a specific set of vars to undefined. This has to be done at

     * the start of each method for local variables that aren't passed as

     * parameters.

     *

     * @param symbols list of symbols.

     */

    private void initSymbols(final Iterable<Symbol> symbols) {

        final LinkedList<Symbol> numbers = new LinkedList<>();

        final LinkedList<Symbol> objects = new LinkedList<>();

        for (final Symbol symbol : symbols) {

            /*

             * The following symbols are guaranteed to be defined and thus safe

             * from having undefined written to them: parameters internals this

             *

             * Otherwise we must, unless we perform control/escape analysis,

             * assign them undefined.

             */

            final boolean isInternal = symbol.isParam() || symbol.isInternal() || symbol.isThis() || !symbol.canBeUndefined();

            if (symbol.hasSlot() && !isInternal) {

                assert symbol.getSymbolType().isNumber() || symbol.getSymbolType().isObject() : "no potentially undefined narrower local vars than doubles are allowed: " + symbol + " in " + lc.getCurrentFunction();

                if (symbol.getSymbolType().isNumber()) {

                    numbers.add(symbol);

                } else if (symbol.getSymbolType().isObject()) {

                    objects.add(symbol);

                }

            }

        }

        initSymbols(numbers, Type.NUMBER);

        initSymbols(objects, Type.OBJECT);

    }

    private void initSymbols(final LinkedList<Symbol> symbols, final Type type) {

        final Iterator<Symbol> it = symbols.iterator();

        if(it.hasNext()) {

            method.loadUndefined(type);

            boolean hasNext;

            do {

                final Symbol symbol = it.next();

                hasNext = it.hasNext();

                if(hasNext) {

                    method.dup();

                }

                method.store(symbol);

            } while(hasNext);

        }

    }

    /**

     * Create symbol debug information.

     *

     * @param block block containing symbols.

     */

    private void symbolInfo(final Block block) {

        for (final Symbol symbol : block.getSymbols()) {

            if (symbol.hasSlot()) {

                method.localVariable(symbol, block.getEntryLabel(), block.getBreakLabel());

            }

        }

    }

    @Override

    public boolean enterBlock(final Block block) {

        method.label(block.getEntryLabel());

        initLocals(block);

        return true;

    }

    @Override

    public Node leaveBlock(final Block block) {

        method.label(block.getBreakLabel());

        symbolInfo(block);

        if (block.needsScope() && !block.isTerminal()) {

            popBlockScope(block);

        }

        return block;

    }

    private void popBlockScope(final Block block) {

        final Label exitLabel     = new Label("block_exit");

        final Label recoveryLabel = new Label("block_catch");