/*

 * Copyright (c) 1999, 2015, 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 com.sun.tools.javac.jvm;

import com.sun.tools.javac.util.*;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

import com.sun.tools.javac.util.List;

import com.sun.tools.javac.code.*;

import com.sun.tools.javac.code.Attribute.TypeCompound;

import com.sun.tools.javac.code.Symbol.VarSymbol;

import com.sun.tools.javac.comp.*;

import com.sun.tools.javac.tree.*;

import com.sun.tools.javac.code.Symbol.*;

import com.sun.tools.javac.code.Type.*;

import com.sun.tools.javac.jvm.Code.*;

import com.sun.tools.javac.jvm.Items.*;

import com.sun.tools.javac.tree.EndPosTable;

import com.sun.tools.javac.tree.JCTree.*;

import static com.sun.tools.javac.code.Flags.*;

import static com.sun.tools.javac.code.Kinds.Kind.*;

import static com.sun.tools.javac.code.TypeTag.*;

import static com.sun.tools.javac.jvm.ByteCodes.*;

import static com.sun.tools.javac.jvm.CRTFlags.*;

import static com.sun.tools.javac.main.Option.*;

import static com.sun.tools.javac.tree.JCTree.Tag.*;

/** This pass maps flat Java (i.e. without inner classes) to bytecodes.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class Gen extends JCTree.Visitor {

    protected static final Context.Key<Gen> genKey = new Context.Key<>();

    private final Log log;

    private final Symtab syms;

    private final Check chk;

    private final Resolve rs;

    private final TreeMaker make;

    private final Names names;

    private final Target target;

    private Name accessDollar;

    private final Types types;

    private final Lower lower;

    private final Flow flow;

    private final Annotate annotate;

    /** Format of stackmap tables to be generated. */

    private final Code.StackMapFormat stackMap;

    /** A type that serves as the expected type for all method expressions.

     */

    private final Type methodType;

    public static Gen instance(Context context) {

        Gen instance = context.get(genKey);

        if (instance == null)

            instance = new Gen(context);

        return instance;

    }

    /** Constant pool, reset by genClass.

     */

    private Pool pool;

    protected Gen(Context context) {

        context.put(genKey, this);

        names = Names.instance(context);

        log = Log.instance(context);

        syms = Symtab.instance(context);

        chk = Check.instance(context);

        rs = Resolve.instance(context);

        make = TreeMaker.instance(context);

        target = Target.instance(context);

        types = Types.instance(context);

        methodType = new MethodType(null, null, null, syms.methodClass);

        accessDollar = names.

            fromString("access" + target.syntheticNameChar());

        flow = Flow.instance(context);

        lower = Lower.instance(context);

        Options options = Options.instance(context);

        lineDebugInfo =

            options.isUnset(G_CUSTOM) ||

            options.isSet(G_CUSTOM, "lines");

        varDebugInfo =

            options.isUnset(G_CUSTOM)

            ? options.isSet(G)

            : options.isSet(G_CUSTOM, "vars");

        genCrt = options.isSet(XJCOV);

        debugCode = options.isSet("debugcode");

        allowInvokedynamic = target.hasInvokedynamic() || options.isSet("invokedynamic");

        allowBetterNullChecks = target.hasObjects();

        pool = new Pool(types);

        // ignore cldc because we cannot have both stackmap formats

        this.stackMap = StackMapFormat.JSR202;

        // by default, avoid jsr's for simple finalizers

        int setjsrlimit = 50;

        String jsrlimitString = options.get("jsrlimit");

        if (jsrlimitString != null) {

            try {

                setjsrlimit = Integer.parseInt(jsrlimitString);

            } catch (NumberFormatException ex) {

                // ignore ill-formed numbers for jsrlimit

            }

        }

        this.jsrlimit = setjsrlimit;

        this.useJsrLocally = false; // reset in visitTry

        annotate = Annotate.instance(context);

    }

    /** Switches

     */

    private final boolean lineDebugInfo;

    private final boolean varDebugInfo;

    private final boolean genCrt;

    private final boolean debugCode;

    private final boolean allowInvokedynamic;

    private final boolean allowBetterNullChecks;

    /** Default limit of (approximate) size of finalizer to inline.

     *  Zero means always use jsr.  100 or greater means never use

     *  jsr.

     */

    private final int jsrlimit;

    /** True if jsr is used.

     */

    private boolean useJsrLocally;

    /** Code buffer, set by genMethod.

     */

    private Code code;

    /** Items structure, set by genMethod.

     */

    private Items items;

    /** Environment for symbol lookup, set by genClass

     */

    private Env<AttrContext> attrEnv;

    /** The top level tree.

     */

    private JCCompilationUnit toplevel;

    /** The number of code-gen errors in this class.

     */

    private int nerrs = 0;

    /** An object containing mappings of syntax trees to their

     *  ending source positions.

     */

    EndPosTable endPosTable;

    /** Generate code to load an integer constant.

     *  @param n     The integer to be loaded.

     */

    void loadIntConst(int n) {

        items.makeImmediateItem(syms.intType, n).load();

    }

    /** The opcode that loads a zero constant of a given type code.

     *  @param tc   The given type code (@see ByteCode).

     */

    public static int zero(int tc) {

        switch(tc) {

        case INTcode: case BYTEcode: case SHORTcode: case CHARcode:

            return iconst_0;

        case LONGcode:

            return lconst_0;

        case FLOATcode:

            return fconst_0;

        case DOUBLEcode:

            return dconst_0;

        default:

            throw new AssertionError("zero");

        }

    }

    /** The opcode that loads a one constant of a given type code.

     *  @param tc   The given type code (@see ByteCode).

     */

    public static int one(int tc) {

        return zero(tc) + 1;

    }

    /** Generate code to load -1 of the given type code (either int or long).

     *  @param tc   The given type code (@see ByteCode).

     */

    void emitMinusOne(int tc) {

        if (tc == LONGcode) {

            items.makeImmediateItem(syms.longType, new Long(-1)).load();

        } else {

            code.emitop0(iconst_m1);

        }

    }

    /** Construct a symbol to reflect the qualifying type that should

     *  appear in the byte code as per JLS 13.1.

     *

     *  For {@literal target >= 1.2}: Clone a method with the qualifier as owner (except

     *  for those cases where we need to work around VM bugs).

     *

     *  For {@literal target <= 1.1}: If qualified variable or method is defined in a

     *  non-accessible class, clone it with the qualifier class as owner.

     *

     *  @param sym    The accessed symbol

     *  @param site   The qualifier's type.

     */

    Symbol binaryQualifier(Symbol sym, Type site) {

        if (site.hasTag(ARRAY)) {

            if (sym == syms.lengthVar ||

                sym.owner != syms.arrayClass)

                return sym;

            // array clone can be qualified by the array type in later targets

            Symbol qualifier = new ClassSymbol(Flags.PUBLIC, site.tsym.name,

                                               site, syms.noSymbol);

            return sym.clone(qualifier);

        }

        if (sym.owner == site.tsym ||

            (sym.flags() & (STATIC | SYNTHETIC)) == (STATIC | SYNTHETIC)) {

            return sym;

        }

        // leave alone methods inherited from Object

        // JLS 13.1.

        if (sym.owner == syms.objectType.tsym)

            return sym;

        return sym.clone(site.tsym);

    }

    /** Insert a reference to given type in the constant pool,

     *  checking for an array with too many dimensions;

     *  return the reference's index.

     *  @param type   The type for which a reference is inserted.

     */

    int makeRef(DiagnosticPosition pos, Type type) {

        checkDimension(pos, type);

        if (type.isAnnotated()) {

            return pool.put((Object)type);

        } else {

            return pool.put(type.hasTag(CLASS) ? (Object)type.tsym : (Object)type);

        }

    }

    /** Check if the given type is an array with too many dimensions.

     */

    private void checkDimension(DiagnosticPosition pos, Type t) {

        switch (t.getTag()) {

        case METHOD:

            checkDimension(pos, t.getReturnType());

            for (List<Type> args = t.getParameterTypes(); args.nonEmpty(); args = args.tail)

                checkDimension(pos, args.head);

            break;

        case ARRAY:

            if (types.dimensions(t) > ClassFile.MAX_DIMENSIONS) {

                log.error(pos, "limit.dimensions");

                nerrs++;

            }

            break;

        default:

            break;

        }

    }

    /** Create a tempory variable.

     *  @param type   The variable's type.

     */

    LocalItem makeTemp(Type type) {

        VarSymbol v = new VarSymbol(Flags.SYNTHETIC,

                                    names.empty,

                                    type,

                                    env.enclMethod.sym);

        code.newLocal(v);

        return items.makeLocalItem(v);

    }

    /** Generate code to call a non-private method or constructor.

     *  @param pos         Position to be used for error reporting.

     *  @param site        The type of which the method is a member.

     *  @param name        The method's name.

     *  @param argtypes    The method's argument types.

     *  @param isStatic    A flag that indicates whether we call a

     *                     static or instance method.

     */

    void callMethod(DiagnosticPosition pos,

                    Type site, Name name, List<Type> argtypes,

                    boolean isStatic) {

        Symbol msym = rs.

            resolveInternalMethod(pos, attrEnv, site, name, argtypes, null);

        if (isStatic) items.makeStaticItem(msym).invoke();

        else items.makeMemberItem(msym, name == names.init).invoke();

    }

    /** Is the given method definition an access method

     *  resulting from a qualified super? This is signified by an odd

     *  access code.

     */

    private boolean isAccessSuper(JCMethodDecl enclMethod) {

        return

            (enclMethod.mods.flags & SYNTHETIC) != 0 &&

            isOddAccessName(enclMethod.name);

    }

    /** Does given name start with "access$" and end in an odd digit?

     */

    private boolean isOddAccessName(Name name) {

        return

            name.startsWith(accessDollar) &&

            (name.getByteAt(name.getByteLength() - 1) & 1) == 1;

    }

/* ************************************************************************

 * Non-local exits

 *************************************************************************/

    /** Generate code to invoke the finalizer associated with given

     *  environment.

     *  Any calls to finalizers are appended to the environments `cont' chain.

     *  Mark beginning of gap in catch all range for finalizer.

     */

    void genFinalizer(Env<GenContext> env) {

        if (code.isAlive() && env.info.finalize != null)

            env.info.finalize.gen();

    }

    /** Generate code to call all finalizers of structures aborted by

     *  a non-local

     *  exit.  Return target environment of the non-local exit.

     *  @param target      The tree representing the structure that's aborted

     *  @param env         The environment current at the non-local exit.

     */

    Env<GenContext> unwind(JCTree target, Env<GenContext> env) {

        Env<GenContext> env1 = env;

        while (true) {

            genFinalizer(env1);

            if (env1.tree == target) break;

            env1 = env1.next;

        }

        return env1;

    }

    /** Mark end of gap in catch-all range for finalizer.

     *  @param env   the environment which might contain the finalizer

     *               (if it does, env.info.gaps != null).

     */

    void endFinalizerGap(Env<GenContext> env) {

        if (env.info.gaps != null && env.info.gaps.length() % 2 == 1)

            env.info.gaps.append(code.curCP());

    }

    /** Mark end of all gaps in catch-all ranges for finalizers of environments

     *  lying between, and including to two environments.

     *  @param from    the most deeply nested environment to mark

     *  @param to      the least deeply nested environment to mark

     */

    void endFinalizerGaps(Env<GenContext> from, Env<GenContext> to) {

        Env<GenContext> last = null;

        while (last != to) {

            endFinalizerGap(from);

            last = from;

            from = from.next;

        }

    }

    /** Do any of the structures aborted by a non-local exit have

     *  finalizers that require an empty stack?

     *  @param target      The tree representing the structure that's aborted

     *  @param env         The environment current at the non-local exit.

     */

    boolean hasFinally(JCTree target, Env<GenContext> env) {

        while (env.tree != target) {

            if (env.tree.hasTag(TRY) && env.info.finalize.hasFinalizer())

                return true;

            env = env.next;

        }

        return false;

    }

/* ************************************************************************

 * Normalizing class-members.

 *************************************************************************/

    /** Distribute member initializer code into constructors and {@code <clinit>}

     *  method.

     *  @param defs         The list of class member declarations.

     *  @param c            The enclosing class.

     */

    List<JCTree> normalizeDefs(List<JCTree> defs, ClassSymbol c) {

        ListBuffer<JCStatement> initCode = new ListBuffer<>();

        ListBuffer<Attribute.TypeCompound> initTAs = new ListBuffer<>();

        ListBuffer<JCStatement> clinitCode = new ListBuffer<>();

        ListBuffer<Attribute.TypeCompound> clinitTAs = new ListBuffer<>();

        ListBuffer<JCTree> methodDefs = new ListBuffer<>();

        // Sort definitions into three listbuffers:

        //  - initCode for instance initializers

        //  - clinitCode for class initializers

        //  - methodDefs for method definitions

        for (List<JCTree> l = defs; l.nonEmpty(); l = l.tail) {

            JCTree def = l.head;

            switch (def.getTag()) {

            case BLOCK:

                JCBlock block = (JCBlock)def;

                if ((block.flags & STATIC) != 0)

                    clinitCode.append(block);

                else if ((block.flags & SYNTHETIC) == 0)

                    initCode.append(block);

                break;

            case METHODDEF:

                methodDefs.append(def);

                break;

            case VARDEF:

                JCVariableDecl vdef = (JCVariableDecl) def;

                VarSymbol sym = vdef.sym;

                checkDimension(vdef.pos(), sym.type);

                if (vdef.init != null) {

                    if ((sym.flags() & STATIC) == 0) {

                        // Always initialize instance variables.

                        JCStatement init = make.at(vdef.pos()).

                            Assignment(sym, vdef.init);

                        initCode.append(init);

                        endPosTable.replaceTree(vdef, init);

                        initTAs.addAll(getAndRemoveNonFieldTAs(sym));

                    } else if (sym.getConstValue() == null) {

                        // Initialize class (static) variables only if

                        // they are not compile-time constants.

                        JCStatement init = make.at(vdef.pos).

                            Assignment(sym, vdef.init);

                        clinitCode.append(init);

                        endPosTable.replaceTree(vdef, init);

                        clinitTAs.addAll(getAndRemoveNonFieldTAs(sym));

                    } else {

                        checkStringConstant(vdef.init.pos(), sym.getConstValue());

                        /* if the init contains a reference to an external class, add it to the

                         * constant's pool

                         */

                        vdef.init.accept(classReferenceVisitor);

                    }

                }

                break;

            default:

                Assert.error();

            }

        }

        // Insert any instance initializers into all constructors.

        if (initCode.length() != 0) {

            List<JCStatement> inits = initCode.toList();

            initTAs.addAll(c.getInitTypeAttributes());

            List<Attribute.TypeCompound> initTAlist = initTAs.toList();

            for (JCTree t : methodDefs) {

                normalizeMethod((JCMethodDecl)t, inits, initTAlist);

            }

        }

        // If there are class initializers, create a <clinit> method

        // that contains them as its body.

        if (clinitCode.length() != 0) {

            MethodSymbol clinit = new MethodSymbol(

                STATIC | (c.flags() & STRICTFP),

                names.clinit,

                new MethodType(

                    List.<Type>nil(), syms.voidType,

                    List.<Type>nil(), syms.methodClass),

                c);

            c.members().enter(clinit);

            List<JCStatement> clinitStats = clinitCode.toList();

            JCBlock block = make.at(clinitStats.head.pos()).Block(0, clinitStats);

            block.endpos = TreeInfo.endPos(clinitStats.last());

            methodDefs.append(make.MethodDef(clinit, block));

            if (!clinitTAs.isEmpty())

                clinit.appendUniqueTypeAttributes(clinitTAs.toList());

            if (!c.getClassInitTypeAttributes().isEmpty())

                clinit.appendUniqueTypeAttributes(c.getClassInitTypeAttributes());

        }

        // Return all method definitions.

        return methodDefs.toList();

    }