/*

 * 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.code.*;

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

import com.sun.tools.javac.resources.CompilerProperties.Errors;

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

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

import java.util.function.ToIntBiFunction;

import java.util.function.ToIntFunction;

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

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

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

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Class;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Double;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Fieldref;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Float;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Integer;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_InterfaceMethodref;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Long;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_MethodHandle;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_MethodType;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Methodref;

import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_String;

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

import static com.sun.tools.javac.jvm.ClassWriter.StackMapTableFrame;

/** An internal structure that corresponds to the code attribute of

 *  methods in a classfile. The class also provides some utility operations to

 *  generate bytecode instructions.

 *

 *  <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 Code {

    public final boolean debugCode;

    public final boolean needStackMap;

    public enum StackMapFormat {

        NONE,

        CLDC {

            Name getAttributeName(Names names) {

                return names.StackMap;

            }

        },

        JSR202 {

            Name getAttributeName(Names names) {

                return names.StackMapTable;

            }

        };

        Name getAttributeName(Names names) {

            return names.empty;

        }

    }

    final Types types;

    final Symtab syms;

    final PoolWriter poolWriter;

/*---------- classfile fields: --------------- */

    /** The maximum stack size.

     */

    public int max_stack = 0;

    /** The maximum number of local variable slots.

     */

    public int max_locals = 0;

    /** The code buffer.

     */

    public byte[] code = new byte[64];

    /** the current code pointer.

     */

    public int cp = 0;

    /** Check the code against VM spec limits; if

     *  problems report them and return true.

     */

    public boolean checkLimits(DiagnosticPosition pos, Log log) {

        if (cp > ClassFile.MAX_CODE) {

            log.error(pos, Errors.LimitCode);

            return true;

        }

        if (max_locals > ClassFile.MAX_LOCALS) {

            log.error(pos, Errors.LimitLocals);

            return true;

        }

        if (max_stack > ClassFile.MAX_STACK) {

            log.error(pos, Errors.LimitStack);

            return true;

        }

        return false;

    }

    /** A buffer for expression catch data. Each enter is a vector

     *  of four unsigned shorts.

     */

    ListBuffer<char[]> catchInfo = new ListBuffer<>();

    /** A buffer for line number information. Each entry is a vector

     *  of two unsigned shorts.

     */

    List<char[]> lineInfo = List.nil(); // handled in stack fashion

    /** The CharacterRangeTable

     */

    public CRTable crt;

/*---------- internal fields: --------------- */

    /** Are we generating code with jumps ≥ 32K?

     */

    public boolean fatcode;

    /** Code generation enabled?

     */

    private boolean alive = true;

    /** The current machine state (registers and stack).

     */

    State state;

    /** Is it forbidden to compactify code, because something is

     *  pointing to current location?

     */

    private boolean fixedPc = false;

    /** The next available register.

     */

    public int nextreg = 0;

    /** A chain for jumps to be resolved before the next opcode is emitted.

     *  We do this lazily to avoid jumps to jumps.

     */

    Chain pendingJumps = null;

    /** The position of the currently statement, if we are at the

     *  start of this statement, NOPOS otherwise.

     *  We need this to emit line numbers lazily, which we need to do

     *  because of jump-to-jump optimization.

     */

    int pendingStatPos = Position.NOPOS;

    /** Set true when a stackMap is needed at the current PC. */

    boolean pendingStackMap = false;

    /** The stack map format to be generated. */

    StackMapFormat stackMap;

    /** Switch: emit variable debug info.

     */

    boolean varDebugInfo;

    /** Switch: emit line number info.

     */

    boolean lineDebugInfo;

    /** Emit line number info if map supplied

     */

    Position.LineMap lineMap;

    final MethodSymbol meth;

    private int letExprStackPos = 0;

    /** Construct a code object, given the settings of the fatcode,

     *  debugging info switches and the CharacterRangeTable.

     */

    public Code(MethodSymbol meth,

                boolean fatcode,

                Position.LineMap lineMap,

                boolean varDebugInfo,

                StackMapFormat stackMap,

                boolean debugCode,

                CRTable crt,

                Symtab syms,

                Types types,

                PoolWriter poolWriter) {

        this.meth = meth;

        this.fatcode = fatcode;

        this.lineMap = lineMap;

        this.lineDebugInfo = lineMap != null;

        this.varDebugInfo = varDebugInfo;

        this.crt = crt;

        this.syms = syms;

        this.types = types;

        this.poolWriter = poolWriter;

        this.debugCode = debugCode;

        this.stackMap = stackMap;

        switch (stackMap) {

        case CLDC:

        case JSR202:

            this.needStackMap = true;

            break;

        default:

            this.needStackMap = false;

        }

        state = new State();

        lvar = new LocalVar[20];

    }

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

 * Typecodes & related stuff

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

    /** Given a type, return its type code (used implicitly in the

     *  JVM architecture).

     */

    public static int typecode(Type type) {

        switch (type.getTag()) {

        case BYTE: return BYTEcode;

        case SHORT: return SHORTcode;

        case CHAR: return CHARcode;

        case INT: return INTcode;

        case LONG: return LONGcode;

        case FLOAT: return FLOATcode;

        case DOUBLE: return DOUBLEcode;

        case BOOLEAN: return BYTEcode;

        case VOID: return VOIDcode;

        case CLASS:

        case ARRAY:

        case METHOD:

        case BOT:

        case TYPEVAR:

        case UNINITIALIZED_THIS:

        case UNINITIALIZED_OBJECT:

            return OBJECTcode;

        default: throw new AssertionError("typecode " + type.getTag());

        }

    }

    /** Collapse type code for subtypes of int to INTcode.

     */

    public static int truncate(int tc) {

        switch (tc) {

        case BYTEcode: case SHORTcode: case CHARcode: return INTcode;

        default: return tc;

        }

    }

    /** The width in bytes of objects of the type.

     */

    public static int width(int typecode) {

        switch (typecode) {

        case LONGcode: case DOUBLEcode: return 2;

        case VOIDcode: return 0;

        default: return 1;

        }

    }

    public static int width(Type type) {

        return type == null ? 1 : width(typecode(type));

    }

    /** The total width taken up by a vector of objects.

     */

    public static int width(List<Type> types) {

        int w = 0;

        for (List<Type> l = types; l.nonEmpty(); l = l.tail)

            w = w + width(l.head);

        return w;

    }

    /** Given a type, return its code for allocating arrays of that type.

     */

    public static int arraycode(Type type) {

        switch (type.getTag()) {

        case BYTE: return 8;

        case BOOLEAN: return 4;

        case SHORT: return 9;

        case CHAR: return 5;

        case INT: return 10;

        case LONG: return 11;

        case FLOAT: return 6;

        case DOUBLE: return 7;

        case CLASS: return 0;

        case ARRAY: return 1;

        default: throw new AssertionError("arraycode " + type);

        }

    }

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

 * Emit code

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

    /** The current output code pointer.

     */

    public int curCP() {

        /*

         * This method has side-effects because calling it can indirectly provoke

         *  extra code generation, like goto instructions, depending on the context

         *  where it's called.

         *  Use with care or even better avoid using it.

         */

        if (pendingJumps != null) {

            resolvePending();

        }

        if (pendingStatPos != Position.NOPOS) {

            markStatBegin();

        }

        fixedPc = true;

        return cp;

    }

    /** Emit a byte of code.

     */

    private  void emit1(int od) {

        if (!alive) return;

        code = ArrayUtils.ensureCapacity(code, cp);

        code[cp++] = (byte)od;

    }

    /** Emit two bytes of code.

     */

    private void emit2(int od) {

        if (!alive) return;

        if (cp + 2 > code.length) {

            emit1(od >> 8);

            emit1(od);

        } else {

            code[cp++] = (byte)(od >> 8);

            code[cp++] = (byte)od;

        }

    }

    /** Emit four bytes of code.

     */

    public void emit4(int od) {

        if (!alive) return;

        if (cp + 4 > code.length) {

            emit1(od >> 24);

            emit1(od >> 16);

            emit1(od >> 8);

            emit1(od);

        } else {

            code[cp++] = (byte)(od >> 24);

            code[cp++] = (byte)(od >> 16);

            code[cp++] = (byte)(od >> 8);

            code[cp++] = (byte)od;

        }

    }

    /** Emit an opcode.

     */

    private void emitop(int op) {

        if (pendingJumps != null) resolvePending();

        if (alive) {

            if (pendingStatPos != Position.NOPOS)

                markStatBegin();

            if (pendingStackMap) {

                pendingStackMap = false;

                emitStackMap();

            }

            if (debugCode)

                System.err.println("emit@" + cp + " stack=" +

                                   state.stacksize + ": " +

                                   mnem(op));

            emit1(op);

        }

    }

    void postop() {

        Assert.check(alive || isStatementStart());

    }

    /** Emit a ldc (or ldc_w) instruction, taking into account operand size

    */

    public void emitLdc(LoadableConstant constant) {

        int od = poolWriter.putConstant(constant);

        if (od <= 255) {

            emitop1(ldc1, od, constant);

        }

        else {

            emitop2(ldc2, od, constant);

        }

    }

    /** Emit a multinewarray instruction.

     */

    public void emitMultianewarray(int ndims, int type, Type arrayType) {

        emitop(multianewarray);

        if (!alive) return;

        emit2(type);

        emit1(ndims);

        state.pop(ndims);

        state.push(arrayType);

    }

    /** Emit newarray.

     */

    public void emitNewarray(int elemcode, Type arrayType) {

        emitop(newarray);

        if (!alive) return;

        emit1(elemcode);

        state.pop(1); // count

        state.push(arrayType);

    }

    /** Emit anewarray.

     */

    public void emitAnewarray(int od, Type arrayType) {

        emitop(anewarray);

        if (!alive) return;

        emit2(od);

        state.pop(1);

        state.push(arrayType);

    }

    /** Emit an invokeinterface instruction.

     */

    public void emitInvokeinterface(Symbol member, Type mtype) {

        int argsize = width(mtype.getParameterTypes());

        emitop(invokeinterface);

        if (!alive) return;

        emit2(poolWriter.putMember(member));

        emit1(argsize + 1);

        emit1(0);

        state.pop(argsize + 1);

        state.push(mtype.getReturnType());

    }

    /** Emit an invokespecial instruction.

     */

    public void emitInvokespecial(Symbol member, Type mtype) {

        int argsize = width(mtype.getParameterTypes());

        emitop(invokespecial);

        if (!alive) return;

        emit2(poolWriter.putMember(member));

        state.pop(argsize);

        if (member.isConstructor())

            state.markInitialized((UninitializedType)state.peek());

        state.pop(1);

        state.push(mtype.getReturnType());

    }

    /** Emit an invokestatic instruction.

     */

    public void emitInvokestatic(Symbol member, Type mtype) {

        int argsize = width(mtype.getParameterTypes());

        emitop(invokestatic);

        if (!alive) return;

        emit2(poolWriter.putMember(member));

        state.pop(argsize);

        state.push(mtype.getReturnType());

    }

    /** Emit an invokevirtual instruction.

     */

    public void emitInvokevirtual(Symbol member, Type mtype) {

        int argsize = width(mtype.getParameterTypes());

        emitop(invokevirtual);

        if (!alive) return;

        emit2(poolWriter.putMember(member));

        state.pop(argsize + 1);

        state.push(mtype.getReturnType());

    }

    /** Emit an invokedynamic instruction.

     */

    public void emitInvokedynamic(DynamicMethodSymbol dynMember, Type mtype) {

        int argsize = width(mtype.getParameterTypes());

        emitop(invokedynamic);

        if (!alive) return;

        emit2(poolWriter.putDynamic(dynMember));

        emit2(0);

        state.pop(argsize);

        state.push(mtype.getReturnType());

    }

    /** Emit an opcode with no operand field.

     */

    public void emitop0(int op) {

        emitop(op);

        if (!alive) return;

        switch (op) {

        case aaload: {

            state.pop(1);// index

            Type a = state.stack[state.stacksize-1];

            Assert.check(!a.hasTag(BOT)); // null type as is cannot be indexed.

            state.pop(1);

            state.push(types.erasure(types.elemtype(a))); }

            break;