/*
 * 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.
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * ASM: a very small and fast Java bytecode manipulation framework
 * Copyright (c) 2000-2011 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package jdk.internal.org.objectweb.asm;

/**
 * The input and output stack map frames of a basic block.
 *
 * <p>Stack map frames are computed in two steps:
 *
 * <ul>
 *   <li>During the visit of each instruction in MethodWriter, the state of the frame at the end of
 *       the current basic block is updated by simulating the action of the instruction on the
 *       previous state of this so called "output frame".
 *   <li>After all instructions have been visited, a fix point algorithm is used in MethodWriter to
 *       compute the "input frame" of each basic block (i.e. the stack map frame at the beginning of
 *       the basic block). See {@link MethodWriter#computeAllFrames}.
 * </ul>
 *
 * <p>Output stack map frames are computed relatively to the input frame of the basic block, which
 * is not yet known when output frames are computed. It is therefore necessary to be able to
 * represent abstract types such as "the type at position x in the input frame locals" or "the type
 * at position x from the top of the input frame stack" or even "the type at position x in the input
 * frame, with y more (or less) array dimensions". This explains the rather complicated type format
 * used in this class, explained below.
 *
 * <p>The local variables and the operand stack of input and output frames contain values called
 * "abstract types" hereafter. An abstract type is represented with 4 fields named DIM, KIND, FLAGS
 * and VALUE, packed in a single int value for better performance and memory efficiency:
 *
 * <pre>
 *   =====================================
 *   |...DIM|KIND|.F|...............VALUE|
 *   =====================================
 * </pre>
 *
 * <ul>
 *   <li>the DIM field, stored in the 6 most significant bits, is a signed number of array
 *       dimensions (from -32 to 31, included). It can be retrieved with {@link #DIM_MASK} and a
 *       right shift of {@link #DIM_SHIFT}.
 *   <li>the KIND field, stored in 4 bits, indicates the kind of VALUE used. These 4 bits can be
 *       retrieved with {@link #KIND_MASK} and, without any shift, must be equal to {@link
 *       #CONSTANT_KIND}, {@link #REFERENCE_KIND}, {@link #UNINITIALIZED_KIND}, {@link #LOCAL_KIND}
 *       or {@link #STACK_KIND}.
 *   <li>the FLAGS field, stored in 2 bits, contains up to 2 boolean flags. Currently only one flag
 *       is defined, namely {@link #TOP_IF_LONG_OR_DOUBLE_FLAG}.
 *   <li>the VALUE field, stored in the remaining 20 bits, contains either
 *       <ul>
 *         <li>one of the constants {@link #ITEM_TOP}, {@link #ITEM_ASM_BOOLEAN}, {@link
 *             #ITEM_ASM_BYTE}, {@link #ITEM_ASM_CHAR} or {@link #ITEM_ASM_SHORT}, {@link
 *             #ITEM_INTEGER}, {@link #ITEM_FLOAT}, {@link #ITEM_LONG}, {@link #ITEM_DOUBLE}, {@link
 *             #ITEM_NULL} or {@link #ITEM_UNINITIALIZED_THIS}, if KIND is equal to {@link
 *             #CONSTANT_KIND}.
 *         <li>the index of a {@link Symbol#TYPE_TAG} {@link Symbol} in the type table of a {@link
 *             SymbolTable}, if KIND is equal to {@link #REFERENCE_KIND}.
 *         <li>the index of an {@link Symbol#UNINITIALIZED_TYPE_TAG} {@link Symbol} in the type
 *             table of a SymbolTable, if KIND is equal to {@link #UNINITIALIZED_KIND}.
 *         <li>the index of a local variable in the input stack frame, if KIND is equal to {@link
 *             #LOCAL_KIND}.
 *         <li>a position relatively to the top of the stack of the input stack frame, if KIND is
 *             equal to {@link #STACK_KIND},
 *       </ul>
 * </ul>
 *
 * <p>Output frames can contain abstract types of any kind and with a positive or negative array
 * dimension (and even unassigned types, represented by 0 - which does not correspond to any valid
 * abstract type value). Input frames can only contain CONSTANT_KIND, REFERENCE_KIND or
 * UNINITIALIZED_KIND abstract types of positive or {@literal null} array dimension. In all cases
 * the type table contains only internal type names (array type descriptors are forbidden - array
 * dimensions must be represented through the DIM field).
 *
 * <p>The LONG and DOUBLE types are always represented by using two slots (LONG + TOP or DOUBLE +
 * TOP), for local variables as well as in the operand stack. This is necessary to be able to
 * simulate DUPx_y instructions, whose effect would be dependent on the concrete types represented
 * by the abstract types in the stack (which are not always known).
 *
 * @author Eric Bruneton
 */
class Frame {

    // Constants used in the StackMapTable attribute.
    // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.4.

    static final int SAME_FRAME = 0;
    static final int SAME_LOCALS_1_STACK_ITEM_FRAME = 64;
    static final int RESERVED = 128;
    static final int SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247;
    static final int CHOP_FRAME = 248;
    static final int SAME_FRAME_EXTENDED = 251;
    static final int APPEND_FRAME = 252;
    static final int FULL_FRAME = 255;

    static final int ITEM_TOP = 0;
    static final int ITEM_INTEGER = 1;
    static final int ITEM_FLOAT = 2;
    static final int ITEM_DOUBLE = 3;
    static final int ITEM_LONG = 4;
    static final int ITEM_NULL = 5;
    static final int ITEM_UNINITIALIZED_THIS = 6;
    static final int ITEM_OBJECT = 7;
    static final int ITEM_UNINITIALIZED = 8;
    // Additional, ASM specific constants used in abstract types below.
    private static final int ITEM_ASM_BOOLEAN = 9;
    private static final int ITEM_ASM_BYTE = 10;
    private static final int ITEM_ASM_CHAR = 11;
    private static final int ITEM_ASM_SHORT = 12;

    // The size and offset in bits of each field of an abstract type.

    private static final int DIM_SIZE = 6;
    private static final int KIND_SIZE = 4;
    private static final int FLAGS_SIZE = 2;
    private static final int VALUE_SIZE = 32 - DIM_SIZE - KIND_SIZE - FLAGS_SIZE;

    private static final int DIM_SHIFT = KIND_SIZE + FLAGS_SIZE + VALUE_SIZE;
    private static final int KIND_SHIFT = FLAGS_SIZE + VALUE_SIZE;
    private static final int FLAGS_SHIFT = VALUE_SIZE;

    // Bitmasks to get each field of an abstract type.

    private static final int DIM_MASK = ((1 << DIM_SIZE) - 1) << DIM_SHIFT;
    private static final int KIND_MASK = ((1 << KIND_SIZE) - 1) << KIND_SHIFT;
    private static final int VALUE_MASK = (1 << VALUE_SIZE) - 1;

    // Constants to manipulate the DIM field of an abstract type.

    /** The constant to be added to an abstract type to get one with one more array dimension. */
    private static final int ARRAY_OF = +1 << DIM_SHIFT;

    /** The constant to be added to an abstract type to get one with one less array dimension. */
    private static final int ELEMENT_OF = -1 << DIM_SHIFT;

    // Possible values for the KIND field of an abstract type.

    private static final int CONSTANT_KIND = 1 << KIND_SHIFT;
    private static final int REFERENCE_KIND = 2 << KIND_SHIFT;
    private static final int UNINITIALIZED_KIND = 3 << KIND_SHIFT;
    private static final int LOCAL_KIND = 4 << KIND_SHIFT;
    private static final int STACK_KIND = 5 << KIND_SHIFT;

    // Possible flags for the FLAGS field of an abstract type.

    /**
      * A flag used for LOCAL_KIND and STACK_KIND abstract types, indicating that if the resolved,
      * concrete type is LONG or DOUBLE, TOP should be used instead (because the value has been
      * partially overridden with an xSTORE instruction).
      */
    private static final int TOP_IF_LONG_OR_DOUBLE_FLAG = 1 << FLAGS_SHIFT;

    // Useful predefined abstract types (all the possible CONSTANT_KIND types).

    private static final int TOP = CONSTANT_KIND | ITEM_TOP;
    private static final int BOOLEAN = CONSTANT_KIND | ITEM_ASM_BOOLEAN;
    private static final int BYTE = CONSTANT_KIND | ITEM_ASM_BYTE;
    private static final int CHAR = CONSTANT_KIND | ITEM_ASM_CHAR;
    private static final int SHORT = CONSTANT_KIND | ITEM_ASM_SHORT;
    private static final int INTEGER = CONSTANT_KIND | ITEM_INTEGER;
    private static final int FLOAT = CONSTANT_KIND | ITEM_FLOAT;
    private static final int LONG = CONSTANT_KIND | ITEM_LONG;
    private static final int DOUBLE = CONSTANT_KIND | ITEM_DOUBLE;
    private static final int NULL = CONSTANT_KIND | ITEM_NULL;
    private static final int UNINITIALIZED_THIS = CONSTANT_KIND | ITEM_UNINITIALIZED_THIS;

    // -----------------------------------------------------------------------------------------------
    // Instance fields
    // -----------------------------------------------------------------------------------------------

    /** The basic block to which these input and output stack map frames correspond. */
    Label owner;

    /** The input stack map frame locals. This is an array of abstract types. */
    private int[] inputLocals;

    /** The input stack map frame stack. This is an array of abstract types. */
    private int[] inputStack;

    /** The output stack map frame locals. This is an array of abstract types. */
    private int[] outputLocals;

    /** The output stack map frame stack. This is an array of abstract types. */
    private int[] outputStack;

    /**
      * The start of the output stack, relatively to the input stack. This offset is always negative or
      * null. A null offset means that the output stack must be appended to the input stack. A -n
      * offset means that the first n output stack elements must replace the top n input stack
      * elements, and that the other elements must be appended to the input stack.
      */
    private short outputStackStart;

    /** The index of the top stack element in {@link #outputStack}. */
    private short outputStackTop;

    /** The number of types that are initialized in the basic block. See {@link #initializations}. */
    private int initializationCount;

    /**
      * The abstract types that are initialized in the basic block. A constructor invocation on an
      * UNINITIALIZED or UNINITIALIZED_THIS abstract type must replace <i>every occurrence</i> of this
      * type in the local variables and in the operand stack. This cannot be done during the first step
      * of the algorithm since, during this step, the local variables and the operand stack types are
      * still abstract. It is therefore necessary to store the abstract types of the constructors which
      * are invoked in the basic block, in order to do this replacement during the second step of the
      * algorithm, where the frames are fully computed. Note that this array can contain abstract types
      * that are relative to the input locals or to the input stack.
      */
    private int[] initializations;

    // -----------------------------------------------------------------------------------------------
    // Constructor
    // -----------------------------------------------------------------------------------------------

    /**
      * Constructs a new Frame.
      *
      * @param owner the basic block to which these input and output stack map frames correspond.
      */
    Frame(final Label owner) {
        this.owner = owner;
    }

    /**
      * Sets this frame to the value of the given frame.
      *
      * <p>WARNING: after this method is called the two frames share the same data structures. It is
      * recommended to discard the given frame to avoid unexpected side effects.
      *
      * @param frame The new frame value.
      */
    final void copyFrom(final Frame frame) {
        inputLocals = frame.inputLocals;
        inputStack = frame.inputStack;
        outputStackStart = 0;
        outputLocals = frame.outputLocals;
        outputStack = frame.outputStack;
        outputStackTop = frame.outputStackTop;
        initializationCount = frame.initializationCount;
        initializations = frame.initializations;
    }

    // -----------------------------------------------------------------------------------------------
    // Static methods to get abstract types from other type formats
    // -----------------------------------------------------------------------------------------------

    /**
      * Returns the abstract type corresponding to the given public API frame element type.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param type a frame element type described using the same format as in {@link
      *     MethodVisitor#visitFrame}, i.e. either {@link Opcodes#TOP}, {@link Opcodes#INTEGER}, {@link
      *     Opcodes#FLOAT}, {@link Opcodes#LONG}, {@link Opcodes#DOUBLE}, {@link Opcodes#NULL}, or
      *     {@link Opcodes#UNINITIALIZED_THIS}, or the internal name of a class, or a Label designating
      *     a NEW instruction (for uninitialized types).
      * @return the abstract type corresponding to the given frame element type.
      */
    static int getAbstractTypeFromApiFormat(final SymbolTable symbolTable, final Object type) {
        if (type instanceof Integer) {
            return CONSTANT_KIND | ((Integer) type).intValue();
        } else if (type instanceof String) {
            String descriptor = Type.getObjectType((String) type).getDescriptor();
            return getAbstractTypeFromDescriptor(symbolTable, descriptor, 0);
        } else {
            return UNINITIALIZED_KIND
                    | symbolTable.addUninitializedType("", ((Label) type).bytecodeOffset);
        }
    }

    /**
      * Returns the abstract type corresponding to the internal name of a class.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param internalName the internal name of a class. This must <i>not</i> be an array type
      *     descriptor.
      * @return the abstract type value corresponding to the given internal name.
      */
    static int getAbstractTypeFromInternalName(
            final SymbolTable symbolTable, final String internalName) {
        return REFERENCE_KIND | symbolTable.addType(internalName);
    }

    /**
      * Returns the abstract type corresponding to the given type descriptor.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param buffer a string ending with a type descriptor.
      * @param offset the start offset of the type descriptor in buffer.
      * @return the abstract type corresponding to the given type descriptor.
      */
    private static int getAbstractTypeFromDescriptor(
            final SymbolTable symbolTable, final String buffer, final int offset) {
        String internalName;
        switch (buffer.charAt(offset)) {
            case 'V':
                return 0;
            case 'Z':
            case 'C':
            case 'B':
            case 'S':
            case 'I':
                return INTEGER;
            case 'F':
                return FLOAT;
            case 'J':
                return LONG;
            case 'D':
                return DOUBLE;
            case 'L':
                internalName = buffer.substring(offset + 1, buffer.length() - 1);
                return REFERENCE_KIND | symbolTable.addType(internalName);
            case '[':
                int elementDescriptorOffset = offset + 1;
                while (buffer.charAt(elementDescriptorOffset) == '[') {
                    ++elementDescriptorOffset;
                }
                int typeValue;
                switch (buffer.charAt(elementDescriptorOffset)) {
                    case 'Z':
                        typeValue = BOOLEAN;
                        break;
                    case 'C':
                        typeValue = CHAR;
                        break;
                    case 'B':
                        typeValue = BYTE;
                        break;
                    case 'S':
                        typeValue = SHORT;
                        break;
                    case 'I':
                        typeValue = INTEGER;
                        break;
                    case 'F':
                        typeValue = FLOAT;
                        break;
                    case 'J':
                        typeValue = LONG;
                        break;
                    case 'D':
                        typeValue = DOUBLE;
                        break;
                    case 'L':
                        internalName = buffer.substring(elementDescriptorOffset + 1, buffer.length() - 1);
                        typeValue = REFERENCE_KIND | symbolTable.addType(internalName);
                        break;
                    default:
                        throw new IllegalArgumentException();
                }
                return ((elementDescriptorOffset - offset) << DIM_SHIFT) | typeValue;
            default:
                throw new IllegalArgumentException();
        }
    }

    // -----------------------------------------------------------------------------------------------
    // Methods related to the input frame
    // -----------------------------------------------------------------------------------------------

    /**
      * Sets the input frame from the given method description. This method is used to initialize the
      * first frame of a method, which is implicit (i.e. not stored explicitly in the StackMapTable
      * attribute).
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param access the method's access flags.
      * @param descriptor the method descriptor.
      * @param maxLocals the maximum number of local variables of the method.
      */
    final void setInputFrameFromDescriptor(
            final SymbolTable symbolTable,
            final int access,
            final String descriptor,
            final int maxLocals) {
        inputLocals = new int[maxLocals];
        inputStack = new int[0];
        int inputLocalIndex = 0;
        if ((access & Opcodes.ACC_STATIC) == 0) {
            if ((access & Constants.ACC_CONSTRUCTOR) == 0) {
                inputLocals[inputLocalIndex++] =
                        REFERENCE_KIND | symbolTable.addType(symbolTable.getClassName());
            } else {
                inputLocals[inputLocalIndex++] = UNINITIALIZED_THIS;
            }
        }
        for (Type argumentType : Type.getArgumentTypes(descriptor)) {
            int abstractType =
                    getAbstractTypeFromDescriptor(symbolTable, argumentType.getDescriptor(), 0);
            inputLocals[inputLocalIndex++] = abstractType;
            if (abstractType == LONG || abstractType == DOUBLE) {
                inputLocals[inputLocalIndex++] = TOP;
            }
        }
        while (inputLocalIndex < maxLocals) {
            inputLocals[inputLocalIndex++] = TOP;
        }
    }

    /**
      * Sets the input frame from the given public API frame description.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param numLocal the number of local variables.
      * @param local the local variable types, described using the same format as in {@link
      *     MethodVisitor#visitFrame}.
      * @param numStack the number of operand stack elements.
      * @param stack the operand stack types, described using the same format as in {@link
      *     MethodVisitor#visitFrame}.
      */
    final void setInputFrameFromApiFormat(
            final SymbolTable symbolTable,
            final int numLocal,
            final Object[] local,
            final int numStack,
            final Object[] stack) {
        int inputLocalIndex = 0;
        for (int i = 0; i < numLocal; ++i) {
            inputLocals[inputLocalIndex++] = getAbstractTypeFromApiFormat(symbolTable, local[i]);
            if (local[i] == Opcodes.LONG || local[i] == Opcodes.DOUBLE) {
                inputLocals[inputLocalIndex++] = TOP;
            }
        }
        while (inputLocalIndex < inputLocals.length) {
            inputLocals[inputLocalIndex++] = TOP;
        }
        int numStackTop = 0;
        for (int i = 0; i < numStack; ++i) {
            if (stack[i] == Opcodes.LONG || stack[i] == Opcodes.DOUBLE) {
                ++numStackTop;
            }
        }
        inputStack = new int[numStack + numStackTop];
        int inputStackIndex = 0;
        for (int i = 0; i < numStack; ++i) {
            inputStack[inputStackIndex++] = getAbstractTypeFromApiFormat(symbolTable, stack[i]);
            if (stack[i] == Opcodes.LONG || stack[i] == Opcodes.DOUBLE) {
                inputStack[inputStackIndex++] = TOP;
            }
        }
        outputStackTop = 0;
        initializationCount = 0;
    }

    final int getInputStackSize() {
        return inputStack.length;
    }

    // -----------------------------------------------------------------------------------------------
    // Methods related to the output frame
    // -----------------------------------------------------------------------------------------------

    /**
      * Returns the abstract type stored at the given local variable index in the output frame.
      *
      * @param localIndex the index of the local variable whose value must be returned.
      * @return the abstract type stored at the given local variable index in the output frame.
      */
    private int getLocal(final int localIndex) {
        if (outputLocals == null || localIndex >= outputLocals.length) {
            // If this local has never been assigned in this basic block, it is still equal to its value
            // in the input frame.
            return LOCAL_KIND | localIndex;
        } else {
            int abstractType = outputLocals[localIndex];
            if (abstractType == 0) {
                // If this local has never been assigned in this basic block, so it is still equal to its
                // value in the input frame.
                abstractType = outputLocals[localIndex] = LOCAL_KIND | localIndex;
            }
            return abstractType;
        }
    }

    /**
      * Replaces the abstract type stored at the given local variable index in the output frame.
      *
      * @param localIndex the index of the output frame local variable that must be set.
      * @param abstractType the value that must be set.
      */
    private void setLocal(final int localIndex, final int abstractType) {
        // Create and/or resize the output local variables array if necessary.
        if (outputLocals == null) {
            outputLocals = new int[10];
        }
        int outputLocalsLength = outputLocals.length;
        if (localIndex >= outputLocalsLength) {
            int[] newOutputLocals = new int[Math.max(localIndex + 1, 2 * outputLocalsLength)];
            System.arraycopy(outputLocals, 0, newOutputLocals, 0, outputLocalsLength);
            outputLocals = newOutputLocals;
        }
        // Set the local variable.
        outputLocals[localIndex] = abstractType;
    }

    /**
      * Pushes the given abstract type on the output frame stack.
      *
      * @param abstractType an abstract type.
      */
    private void push(final int abstractType) {
        // Create and/or resize the output stack array if necessary.
        if (outputStack == null) {
            outputStack = new int[10];
        }
        int outputStackLength = outputStack.length;
        if (outputStackTop >= outputStackLength) {
            int[] newOutputStack = new int[Math.max(outputStackTop + 1, 2 * outputStackLength)];
            System.arraycopy(outputStack, 0, newOutputStack, 0, outputStackLength);
            outputStack = newOutputStack;
        }
        // Pushes the abstract type on the output stack.
        outputStack[outputStackTop++] = abstractType;
        // Updates the maximum size reached by the output stack, if needed (note that this size is
        // relative to the input stack size, which is not known yet).
        short outputStackSize = (short) (outputStackStart + outputStackTop);
        if (outputStackSize > owner.outputStackMax) {
            owner.outputStackMax = outputStackSize;
        }
    }

    /**
      * Pushes the abstract type corresponding to the given descriptor on the output frame stack.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param descriptor a type or method descriptor (in which case its return type is pushed).
      */
    private void push(final SymbolTable symbolTable, final String descriptor) {
        int typeDescriptorOffset =
                descriptor.charAt(0) == '(' ? Type.getReturnTypeOffset(descriptor) : 0;
        int abstractType = getAbstractTypeFromDescriptor(symbolTable, descriptor, typeDescriptorOffset);
        if (abstractType != 0) {
            push(abstractType);
            if (abstractType == LONG || abstractType == DOUBLE) {
                push(TOP);
            }
        }
    }

    /**
      * Pops an abstract type from the output frame stack and returns its value.
      *
      * @return the abstract type that has been popped from the output frame stack.
      */
    private int pop() {
        if (outputStackTop > 0) {
            return outputStack[--outputStackTop];
        } else {
            // If the output frame stack is empty, pop from the input stack.
            return STACK_KIND | -(--outputStackStart);
        }
    }

    /**
      * Pops the given number of abstract types from the output frame stack.
      *
      * @param elements the number of abstract types that must be popped.
      */
    private void pop(final int elements) {
        if (outputStackTop >= elements) {
            outputStackTop -= elements;
        } else {
            // If the number of elements to be popped is greater than the number of elements in the output
            // stack, clear it, and pop the remaining elements from the input stack.
            outputStackStart -= elements - outputStackTop;
            outputStackTop = 0;
        }
    }

    /**
      * Pops as many abstract types from the output frame stack as described by the given descriptor.
      *
      * @param descriptor a type or method descriptor (in which case its argument types are popped).
      */
    private void pop(final String descriptor) {
        char firstDescriptorChar = descriptor.charAt(0);
        if (firstDescriptorChar == '(') {
            pop((Type.getArgumentsAndReturnSizes(descriptor) >> 2) - 1);
        } else if (firstDescriptorChar == 'J' || firstDescriptorChar == 'D') {
            pop(2);
        } else {
            pop(1);
        }
    }

    // -----------------------------------------------------------------------------------------------
    // Methods to handle uninitialized types
    // -----------------------------------------------------------------------------------------------

    /**
      * Adds an abstract type to the list of types on which a constructor is invoked in the basic
      * block.
      *
      * @param abstractType an abstract type on a which a constructor is invoked.
      */
    private void addInitializedType(final int abstractType) {
        // Create and/or resize the initializations array if necessary.
        if (initializations == null) {
            initializations = new int[2];
        }
        int initializationsLength = initializations.length;
        if (initializationCount >= initializationsLength) {
            int[] newInitializations =
                    new int[Math.max(initializationCount + 1, 2 * initializationsLength)];
            System.arraycopy(initializations, 0, newInitializations, 0, initializationsLength);
            initializations = newInitializations;
        }
        // Store the abstract type.
        initializations[initializationCount++] = abstractType;
    }

    /**
      * Returns the "initialized" abstract type corresponding to the given abstract type.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param abstractType an abstract type.
      * @return the REFERENCE_KIND abstract type corresponding to abstractType if it is
      *     UNINITIALIZED_THIS or an UNINITIALIZED_KIND abstract type for one of the types on which a
      *     constructor is invoked in the basic block. Otherwise returns abstractType.
      */
    private int getInitializedType(final SymbolTable symbolTable, final int abstractType) {
        if (abstractType == UNINITIALIZED_THIS
                || (abstractType & (DIM_MASK | KIND_MASK)) == UNINITIALIZED_KIND) {
            for (int i = 0; i < initializationCount; ++i) {
                int initializedType = initializations[i];
                int dim = initializedType & DIM_MASK;
                int kind = initializedType & KIND_MASK;
                int value = initializedType & VALUE_MASK;
                if (kind == LOCAL_KIND) {
                    initializedType = dim + inputLocals[value];
                } else if (kind == STACK_KIND) {
                    initializedType = dim + inputStack[inputStack.length - value];
                }
                if (abstractType == initializedType) {
                    if (abstractType == UNINITIALIZED_THIS) {
                        return REFERENCE_KIND | symbolTable.addType(symbolTable.getClassName());
                    } else {
                        return REFERENCE_KIND
                                | symbolTable.addType(symbolTable.getType(abstractType & VALUE_MASK).value);
                    }
                }
            }
        }
        return abstractType;
    }

    // -----------------------------------------------------------------------------------------------
    // Main method, to simulate the execution of each instruction on the output frame
    // -----------------------------------------------------------------------------------------------

    /**
      * Simulates the action of the given instruction on the output stack frame.
      *
      * @param opcode the opcode of the instruction.
      * @param arg the numeric operand of the instruction, if any.
      * @param argSymbol the Symbol operand of the instruction, if any.
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      */
    void execute(
            final int opcode, final int arg, final Symbol argSymbol, final SymbolTable symbolTable) {
        // Abstract types popped from the stack or read from local variables.
        int abstractType1;
        int abstractType2;
        int abstractType3;
        int abstractType4;
        switch (opcode) {
            case Opcodes.NOP:
            case Opcodes.INEG:
            case Opcodes.LNEG:
            case Opcodes.FNEG:
            case Opcodes.DNEG:
            case Opcodes.I2B:
            case Opcodes.I2C:
            case Opcodes.I2S:
            case Opcodes.GOTO:
            case Opcodes.RETURN:
                break;
            case Opcodes.ACONST_NULL:
                push(NULL);
                break;
            case Opcodes.ICONST_M1:
            case Opcodes.ICONST_0:
            case Opcodes.ICONST_1:
            case Opcodes.ICONST_2:
            case Opcodes.ICONST_3:
            case Opcodes.ICONST_4:
            case Opcodes.ICONST_5:
            case Opcodes.BIPUSH:
            case Opcodes.SIPUSH:
            case Opcodes.ILOAD:
                push(INTEGER);
                break;
            case Opcodes.LCONST_0:
            case Opcodes.LCONST_1:
            case Opcodes.LLOAD:
                push(LONG);
                push(TOP);
                break;
            case Opcodes.FCONST_0:
            case Opcodes.FCONST_1:
            case Opcodes.FCONST_2:
            case Opcodes.FLOAD:
                push(FLOAT);
                break;
            case Opcodes.DCONST_0:
            case Opcodes.DCONST_1:
            case Opcodes.DLOAD:
                push(DOUBLE);
                push(TOP);
                break;
            case Opcodes.LDC:
                switch (argSymbol.tag) {
                    case Symbol.CONSTANT_INTEGER_TAG:
                        push(INTEGER);
                        break;
                    case Symbol.CONSTANT_LONG_TAG:
                        push(LONG);
                        push(TOP);
                        break;
                    case Symbol.CONSTANT_FLOAT_TAG:
                        push(FLOAT);
                        break;
                    case Symbol.CONSTANT_DOUBLE_TAG:
                        push(DOUBLE);
                        push(TOP);
                        break;
                    case Symbol.CONSTANT_CLASS_TAG:
                        push(REFERENCE_KIND | symbolTable.addType("java/lang/Class"));
                        break;
                    case Symbol.CONSTANT_STRING_TAG:
                        push(REFERENCE_KIND | symbolTable.addType("java/lang/String"));
                        break;
                    case Symbol.CONSTANT_METHOD_TYPE_TAG:
                        push(REFERENCE_KIND | symbolTable.addType("java/lang/invoke/MethodType"));
                        break;
                    case Symbol.CONSTANT_METHOD_HANDLE_TAG:
                        push(REFERENCE_KIND | symbolTable.addType("java/lang/invoke/MethodHandle"));
                        break;
                    case Symbol.CONSTANT_DYNAMIC_TAG:
                        push(symbolTable, argSymbol.value);
                        break;
                    default:
                        throw new AssertionError();
                }
                break;
            case Opcodes.ALOAD:
                push(getLocal(arg));
                break;
            case Opcodes.LALOAD:
            case Opcodes.D2L:
                pop(2);
                push(LONG);
                push(TOP);
                break;
            case Opcodes.DALOAD:
            case Opcodes.L2D:
                pop(2);
                push(DOUBLE);
                push(TOP);
                break;
            case Opcodes.AALOAD:
                pop(1);
                abstractType1 = pop();
                push(abstractType1 == NULL ? abstractType1 : ELEMENT_OF + abstractType1);
                break;
            case Opcodes.ISTORE:
            case Opcodes.FSTORE:
            case Opcodes.ASTORE:
                abstractType1 = pop();
                setLocal(arg, abstractType1);
                if (arg > 0) {
                    int previousLocalType = getLocal(arg - 1);
                    if (previousLocalType == LONG || previousLocalType == DOUBLE) {
                        setLocal(arg - 1, TOP);
                    } else if ((previousLocalType & KIND_MASK) == LOCAL_KIND
                            || (previousLocalType & KIND_MASK) == STACK_KIND) {
                        // The type of the previous local variable is not known yet, but if it later appears
                        // to be LONG or DOUBLE, we should then use TOP instead.
                        setLocal(arg - 1, previousLocalType | TOP_IF_LONG_OR_DOUBLE_FLAG);
                    }
                }
                break;
            case Opcodes.LSTORE:
            case Opcodes.DSTORE:
                pop(1);
                abstractType1 = pop();
                setLocal(arg, abstractType1);
                setLocal(arg + 1, TOP);
                if (arg > 0) {
                    int previousLocalType = getLocal(arg - 1);
                    if (previousLocalType == LONG || previousLocalType == DOUBLE) {
                        setLocal(arg - 1, TOP);
                    } else if ((previousLocalType & KIND_MASK) == LOCAL_KIND
                            || (previousLocalType & KIND_MASK) == STACK_KIND) {
                        // The type of the previous local variable is not known yet, but if it later appears
                        // to be LONG or DOUBLE, we should then use TOP instead.
                        setLocal(arg - 1, previousLocalType | TOP_IF_LONG_OR_DOUBLE_FLAG);
                    }
                }
                break;
            case Opcodes.IASTORE:
            case Opcodes.BASTORE:
            case Opcodes.CASTORE:
            case Opcodes.SASTORE:
            case Opcodes.FASTORE:
            case Opcodes.AASTORE:
                pop(3);
                break;
            case Opcodes.LASTORE:
            case Opcodes.DASTORE:
                pop(4);
                break;
            case Opcodes.POP:
            case Opcodes.IFEQ:
            case Opcodes.IFNE:
            case Opcodes.IFLT:
            case Opcodes.IFGE:
            case Opcodes.IFGT:
            case Opcodes.IFLE:
            case Opcodes.IRETURN:
            case Opcodes.FRETURN:
            case Opcodes.ARETURN:
            case Opcodes.TABLESWITCH:
            case Opcodes.LOOKUPSWITCH:
            case Opcodes.ATHROW:
            case Opcodes.MONITORENTER:
            case Opcodes.MONITOREXIT:
            case Opcodes.IFNULL:
            case Opcodes.IFNONNULL:
                pop(1);
                break;
            case Opcodes.POP2:
            case Opcodes.IF_ICMPEQ:
            case Opcodes.IF_ICMPNE:
            case Opcodes.IF_ICMPLT:
            case Opcodes.IF_ICMPGE:
            case Opcodes.IF_ICMPGT:
            case Opcodes.IF_ICMPLE:
            case Opcodes.IF_ACMPEQ:
            case Opcodes.IF_ACMPNE:
            case Opcodes.LRETURN:
            case Opcodes.DRETURN:
                pop(2);
                break;
            case Opcodes.DUP:
                abstractType1 = pop();
                push(abstractType1);
                push(abstractType1);
                break;
            case Opcodes.DUP_X1:
                abstractType1 = pop();
                abstractType2 = pop();
                push(abstractType1);
                push(abstractType2);
                push(abstractType1);
                break;
            case Opcodes.DUP_X2:
                abstractType1 = pop();
                abstractType2 = pop();
                abstractType3 = pop();
                push(abstractType1);
                push(abstractType3);
                push(abstractType2);
                push(abstractType1);
                break;
            case Opcodes.DUP2:
                abstractType1 = pop();
                abstractType2 = pop();
                push(abstractType2);
                push(abstractType1);
                push(abstractType2);
                push(abstractType1);
                break;
            case Opcodes.DUP2_X1:
                abstractType1 = pop();
                abstractType2 = pop();
                abstractType3 = pop();
                push(abstractType2);
                push(abstractType1);
                push(abstractType3);
                push(abstractType2);
                push(abstractType1);
                break;
            case Opcodes.DUP2_X2:
                abstractType1 = pop();
                abstractType2 = pop();
                abstractType3 = pop();
                abstractType4 = pop();
                push(abstractType2);
                push(abstractType1);
                push(abstractType4);
                push(abstractType3);
                push(abstractType2);
                push(abstractType1);
                break;
            case Opcodes.SWAP:
                abstractType1 = pop();
                abstractType2 = pop();
                push(abstractType1);
                push(abstractType2);
                break;
            case Opcodes.IALOAD:
            case Opcodes.BALOAD:
            case Opcodes.CALOAD:
            case Opcodes.SALOAD:
            case Opcodes.IADD:
            case Opcodes.ISUB:
            case Opcodes.IMUL:
            case Opcodes.IDIV:
            case Opcodes.IREM:
            case Opcodes.IAND:
            case Opcodes.IOR:
            case Opcodes.IXOR:
            case Opcodes.ISHL:
            case Opcodes.ISHR:
            case Opcodes.IUSHR:
            case Opcodes.L2I:
            case Opcodes.D2I:
            case Opcodes.FCMPL:
            case Opcodes.FCMPG:
                pop(2);
                push(INTEGER);
                break;
            case Opcodes.LADD:
            case Opcodes.LSUB:
            case Opcodes.LMUL:
            case Opcodes.LDIV:
            case Opcodes.LREM:
            case Opcodes.LAND:
            case Opcodes.LOR:
            case Opcodes.LXOR:
                pop(4);
                push(LONG);
                push(TOP);
                break;
            case Opcodes.FALOAD:
            case Opcodes.FADD:
            case Opcodes.FSUB:
            case Opcodes.FMUL:
            case Opcodes.FDIV:
            case Opcodes.FREM:
            case Opcodes.L2F:
            case Opcodes.D2F:
                pop(2);
                push(FLOAT);
                break;
            case Opcodes.DADD:
            case Opcodes.DSUB:
            case Opcodes.DMUL:
            case Opcodes.DDIV:
            case Opcodes.DREM:
                pop(4);
                push(DOUBLE);
                push(TOP);
                break;
            case Opcodes.LSHL:
            case Opcodes.LSHR:
            case Opcodes.LUSHR:
                pop(3);
                push(LONG);
                push(TOP);
                break;
            case Opcodes.IINC:
                setLocal(arg, INTEGER);
                break;
            case Opcodes.I2L:
            case Opcodes.F2L:
                pop(1);
                push(LONG);
                push(TOP);
                break;
            case Opcodes.I2F:
                pop(1);
                push(FLOAT);
                break;
            case Opcodes.I2D:
            case Opcodes.F2D:
                pop(1);
                push(DOUBLE);
                push(TOP);
                break;
            case Opcodes.F2I:
            case Opcodes.ARRAYLENGTH:
            case Opcodes.INSTANCEOF:
                pop(1);
                push(INTEGER);
                break;
            case Opcodes.LCMP:
            case Opcodes.DCMPL:
            case Opcodes.DCMPG:
                pop(4);
                push(INTEGER);
                break;
            case Opcodes.JSR:
            case Opcodes.RET:
                throw new IllegalArgumentException("JSR/RET are not supported with computeFrames option");
            case Opcodes.GETSTATIC:
                push(symbolTable, argSymbol.value);
                break;
            case Opcodes.PUTSTATIC:
                pop(argSymbol.value);
                break;
            case Opcodes.GETFIELD:
                pop(1);
                push(symbolTable, argSymbol.value);
                break;
            case Opcodes.PUTFIELD:
                pop(argSymbol.value);
                pop();
                break;
            case Opcodes.INVOKEVIRTUAL:
            case Opcodes.INVOKESPECIAL:
            case Opcodes.INVOKESTATIC:
            case Opcodes.INVOKEINTERFACE:
                pop(argSymbol.value);
                if (opcode != Opcodes.INVOKESTATIC) {
                    abstractType1 = pop();
                    if (opcode == Opcodes.INVOKESPECIAL && argSymbol.name.charAt(0) == '<') {
                        addInitializedType(abstractType1);
                    }
                }
                push(symbolTable, argSymbol.value);
                break;
            case Opcodes.INVOKEDYNAMIC:
                pop(argSymbol.value);
                push(symbolTable, argSymbol.value);
                break;
            case Opcodes.NEW:
                push(UNINITIALIZED_KIND | symbolTable.addUninitializedType(argSymbol.value, arg));
                break;
            case Opcodes.NEWARRAY:
                pop();
                switch (arg) {
                    case Opcodes.T_BOOLEAN:
                        push(ARRAY_OF | BOOLEAN);
                        break;
                    case Opcodes.T_CHAR:
                        push(ARRAY_OF | CHAR);
                        break;
                    case Opcodes.T_BYTE:
                        push(ARRAY_OF | BYTE);
                        break;
                    case Opcodes.T_SHORT:
                        push(ARRAY_OF | SHORT);
                        break;
                    case Opcodes.T_INT:
                        push(ARRAY_OF | INTEGER);
                        break;
                    case Opcodes.T_FLOAT:
                        push(ARRAY_OF | FLOAT);
                        break;
                    case Opcodes.T_DOUBLE:
                        push(ARRAY_OF | DOUBLE);
                        break;
                    case Opcodes.T_LONG:
                        push(ARRAY_OF | LONG);
                        break;
                    default:
                        throw new IllegalArgumentException();
                }
                break;
            case Opcodes.ANEWARRAY:
                String arrayElementType = argSymbol.value;
                pop();
                if (arrayElementType.charAt(0) == '[') {
                    push(symbolTable, '[' + arrayElementType);
                } else {
                    push(ARRAY_OF | REFERENCE_KIND | symbolTable.addType(arrayElementType));
                }
                break;
            case Opcodes.CHECKCAST:
                String castType = argSymbol.value;
                pop();
                if (castType.charAt(0) == '[') {
                    push(symbolTable, castType);
                } else {
                    push(REFERENCE_KIND | symbolTable.addType(castType));
                }
                break;
            case Opcodes.MULTIANEWARRAY:
                pop(arg);
                push(symbolTable, argSymbol.value);
                break;
            default:
                throw new IllegalArgumentException();
        }
    }

    // -----------------------------------------------------------------------------------------------
    // Frame merging methods, used in the second step of the stack map frame computation algorithm
    // -----------------------------------------------------------------------------------------------

    /**
      * Computes the concrete output type corresponding to a given abstract output type.
      *
      * @param abstractOutputType an abstract output type.
      * @param numStack the size of the input stack, used to resolve abstract output types of
      *     STACK_KIND kind.
      * @return the concrete output type corresponding to 'abstractOutputType'.
      */
    private int getConcreteOutputType(final int abstractOutputType, final int numStack) {
        int dim = abstractOutputType & DIM_MASK;
        int kind = abstractOutputType & KIND_MASK;
        if (kind == LOCAL_KIND) {
            // By definition, a LOCAL_KIND type designates the concrete type of a local variable at
            // the beginning of the basic block corresponding to this frame (which is known when
            // this method is called, but was not when the abstract type was computed).
            int concreteOutputType = dim + inputLocals[abstractOutputType & VALUE_MASK];
            if ((abstractOutputType & TOP_IF_LONG_OR_DOUBLE_FLAG) != 0
                    && (concreteOutputType == LONG || concreteOutputType == DOUBLE)) {
                concreteOutputType = TOP;
            }
            return concreteOutputType;
        } else if (kind == STACK_KIND) {
            // By definition, a STACK_KIND type designates the concrete type of a local variable at
            // the beginning of the basic block corresponding to this frame (which is known when
            // this method is called, but was not when the abstract type was computed).
            int concreteOutputType = dim + inputStack[numStack - (abstractOutputType & VALUE_MASK)];
            if ((abstractOutputType & TOP_IF_LONG_OR_DOUBLE_FLAG) != 0
                    && (concreteOutputType == LONG || concreteOutputType == DOUBLE)) {
                concreteOutputType = TOP;
            }
            return concreteOutputType;
        } else {
            return abstractOutputType;
        }
    }

    /**
      * Merges the input frame of the given {@link Frame} with the input and output frames of this
      * {@link Frame}. Returns {@literal true} if the given frame has been changed by this operation
      * (the input and output frames of this {@link Frame} are never changed).
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param dstFrame the {@link Frame} whose input frame must be updated. This should be the frame
      *     of a successor, in the control flow graph, of the basic block corresponding to this frame.
      * @param catchTypeIndex if 'frame' corresponds to an exception handler basic block, the type
      *     table index of the caught exception type, otherwise 0.
      * @return {@literal true} if the input frame of 'frame' has been changed by this operation.
      */
    final boolean merge(
            final SymbolTable symbolTable, final Frame dstFrame, final int catchTypeIndex) {
        boolean frameChanged = false;

        // Compute the concrete types of the local variables at the end of the basic block corresponding
        // to this frame, by resolving its abstract output types, and merge these concrete types with
        // those of the local variables in the input frame of dstFrame.
        int numLocal = inputLocals.length;
        int numStack = inputStack.length;
        if (dstFrame.inputLocals == null) {
            dstFrame.inputLocals = new int[numLocal];
            frameChanged = true;
        }
        for (int i = 0; i < numLocal; ++i) {
            int concreteOutputType;
            if (outputLocals != null && i < outputLocals.length) {
                int abstractOutputType = outputLocals[i];
                if (abstractOutputType == 0) {
                    // If the local variable has never been assigned in this basic block, it is equal to its
                    // value at the beginning of the block.
                    concreteOutputType = inputLocals[i];
                } else {
                    concreteOutputType = getConcreteOutputType(abstractOutputType, numStack);
                }
            } else {
                // If the local variable has never been assigned in this basic block, it is equal to its
                // value at the beginning of the block.
                concreteOutputType = inputLocals[i];
            }
            // concreteOutputType might be an uninitialized type from the input locals or from the input
            // stack. However, if a constructor has been called for this class type in the basic block,
            // then this type is no longer uninitialized at the end of basic block.
            if (initializations != null) {
                concreteOutputType = getInitializedType(symbolTable, concreteOutputType);
            }
            frameChanged |= merge(symbolTable, concreteOutputType, dstFrame.inputLocals, i);
        }

        // If dstFrame is an exception handler block, it can be reached from any instruction of the
        // basic block corresponding to this frame, in particular from the first one. Therefore, the
        // input locals of dstFrame should be compatible (i.e. merged) with the input locals of this
        // frame (and the input stack of dstFrame should be compatible, i.e. merged, with a one
        // element stack containing the caught exception type).
        if (catchTypeIndex > 0) {
            for (int i = 0; i < numLocal; ++i) {
                frameChanged |= merge(symbolTable, inputLocals[i], dstFrame.inputLocals, i);
            }
            if (dstFrame.inputStack == null) {
                dstFrame.inputStack = new int[1];
                frameChanged = true;
            }
            frameChanged |= merge(symbolTable, catchTypeIndex, dstFrame.inputStack, 0);
            return frameChanged;
        }

        // Compute the concrete types of the stack operands at the end of the basic block corresponding
        // to this frame, by resolving its abstract output types, and merge these concrete types with
        // those of the stack operands in the input frame of dstFrame.
        int numInputStack = inputStack.length + outputStackStart;
        if (dstFrame.inputStack == null) {
            dstFrame.inputStack = new int[numInputStack + outputStackTop];
            frameChanged = true;
        }
        // First, do this for the stack operands that have not been popped in the basic block
        // corresponding to this frame, and which are therefore equal to their value in the input
        // frame (except for uninitialized types, which may have been initialized).
        for (int i = 0; i < numInputStack; ++i) {
            int concreteOutputType = inputStack[i];
            if (initializations != null) {
                concreteOutputType = getInitializedType(symbolTable, concreteOutputType);
            }
            frameChanged |= merge(symbolTable, concreteOutputType, dstFrame.inputStack, i);
        }
        // Then, do this for the stack operands that have pushed in the basic block (this code is the
        // same as the one above for local variables).
        for (int i = 0; i < outputStackTop; ++i) {
            int abstractOutputType = outputStack[i];
            int concreteOutputType = getConcreteOutputType(abstractOutputType, numStack);
            if (initializations != null) {
                concreteOutputType = getInitializedType(symbolTable, concreteOutputType);
            }
            frameChanged |=
                    merge(symbolTable, concreteOutputType, dstFrame.inputStack, numInputStack + i);
        }
        return frameChanged;
    }

    /**
      * Merges the type at the given index in the given abstract type array with the given type.
      * Returns {@literal true} if the type array has been modified by this operation.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param sourceType the abstract type with which the abstract type array element must be merged.
      *     This type should be of {@link #CONSTANT_KIND}, {@link #REFERENCE_KIND} or {@link
      *     #UNINITIALIZED_KIND} kind, with positive or {@literal null} array dimensions.
      * @param dstTypes an array of abstract types. These types should be of {@link #CONSTANT_KIND},
      *     {@link #REFERENCE_KIND} or {@link #UNINITIALIZED_KIND} kind, with positive or {@literal
      *     null} array dimensions.
      * @param dstIndex the index of the type that must be merged in dstTypes.
      * @return {@literal true} if the type array has been modified by this operation.
      */
    private static boolean merge(
            final SymbolTable symbolTable,
            final int sourceType,
            final int[] dstTypes,
            final int dstIndex) {
        int dstType = dstTypes[dstIndex];
        if (dstType == sourceType) {
            // If the types are equal, merge(sourceType, dstType) = dstType, so there is no change.
            return false;
        }
        int srcType = sourceType;
        if ((sourceType & ~DIM_MASK) == NULL) {
            if (dstType == NULL) {
                return false;
            }
            srcType = NULL;
        }
        if (dstType == 0) {
            // If dstTypes[dstIndex] has never been assigned, merge(srcType, dstType) = srcType.
            dstTypes[dstIndex] = srcType;
            return true;
        }
        int mergedType;
        if ((dstType & DIM_MASK) != 0 || (dstType & KIND_MASK) == REFERENCE_KIND) {
            // If dstType is a reference type of any array dimension.
            if (srcType == NULL) {
                // If srcType is the NULL type, merge(srcType, dstType) = dstType, so there is no change.
                return false;
            } else if ((srcType & (DIM_MASK | KIND_MASK)) == (dstType & (DIM_MASK | KIND_MASK))) {
                // If srcType has the same array dimension and the same kind as dstType.
                if ((dstType & KIND_MASK) == REFERENCE_KIND) {
                    // If srcType and dstType are reference types with the same array dimension,
                    // merge(srcType, dstType) = dim(srcType) | common super class of srcType and dstType.
                    mergedType =
                            (srcType & DIM_MASK)
                                    | REFERENCE_KIND
                                    | symbolTable.addMergedType(srcType & VALUE_MASK, dstType & VALUE_MASK);
                } else {
                    // If srcType and dstType are array types of equal dimension but different element types,
                    // merge(srcType, dstType) = dim(srcType) - 1 | java/lang/Object.
                    int mergedDim = ELEMENT_OF + (srcType & DIM_MASK);
                    mergedType = mergedDim | REFERENCE_KIND | symbolTable.addType("java/lang/Object");
                }
            } else if ((srcType & DIM_MASK) != 0 || (srcType & KIND_MASK) == REFERENCE_KIND) {
                // If srcType is any other reference or array type,
                // merge(srcType, dstType) = min(srcDdim, dstDim) | java/lang/Object
                // where srcDim is the array dimension of srcType, minus 1 if srcType is an array type
                // with a non reference element type (and similarly for dstDim).
                int srcDim = srcType & DIM_MASK;
                if (srcDim != 0 && (srcType & KIND_MASK) != REFERENCE_KIND) {
                    srcDim = ELEMENT_OF + srcDim;
                }
                int dstDim = dstType & DIM_MASK;
                if (dstDim != 0 && (dstType & KIND_MASK) != REFERENCE_KIND) {
                    dstDim = ELEMENT_OF + dstDim;
                }
                mergedType =
                        Math.min(srcDim, dstDim) | REFERENCE_KIND | symbolTable.addType("java/lang/Object");
            } else {
                // If srcType is any other type, merge(srcType, dstType) = TOP.
                mergedType = TOP;
            }
        } else if (dstType == NULL) {
            // If dstType is the NULL type, merge(srcType, dstType) = srcType, or TOP if srcType is not a
            // an array type or a reference type.
            mergedType =
                    (srcType & DIM_MASK) != 0 || (srcType & KIND_MASK) == REFERENCE_KIND ? srcType : TOP;
        } else {
            // If dstType is any other type, merge(srcType, dstType) = TOP whatever srcType.
            mergedType = TOP;
        }
        if (mergedType != dstType) {
            dstTypes[dstIndex] = mergedType;
            return true;
        }
        return false;
    }

    // -----------------------------------------------------------------------------------------------
    // Frame output methods, to generate StackMapFrame attributes
    // -----------------------------------------------------------------------------------------------

    /**
      * Makes the given {@link MethodWriter} visit the input frame of this {@link Frame}. The visit is
      * done with the {@link MethodWriter#visitFrameStart}, {@link MethodWriter#visitAbstractType} and
      * {@link MethodWriter#visitFrameEnd} methods.
      *
      * @param methodWriter the {@link MethodWriter} that should visit the input frame of this {@link
      *     Frame}.
      */
    final void accept(final MethodWriter methodWriter) {
        // Compute the number of locals, ignoring TOP types that are just after a LONG or a DOUBLE, and
        // all trailing TOP types.
        int[] localTypes = inputLocals;
        int numLocal = 0;
        int numTrailingTop = 0;
        int i = 0;
        while (i < localTypes.length) {
            int localType = localTypes[i];
            i += (localType == LONG || localType == DOUBLE) ? 2 : 1;
            if (localType == TOP) {
                numTrailingTop++;
            } else {
                numLocal += numTrailingTop + 1;
                numTrailingTop = 0;
            }
        }
        // Compute the stack size, ignoring TOP types that are just after a LONG or a DOUBLE.
        int[] stackTypes = inputStack;
        int numStack = 0;
        i = 0;
        while (i < stackTypes.length) {
            int stackType = stackTypes[i];
            i += (stackType == LONG || stackType == DOUBLE) ? 2 : 1;
            numStack++;
        }
        // Visit the frame and its content.
        int frameIndex = methodWriter.visitFrameStart(owner.bytecodeOffset, numLocal, numStack);
        i = 0;
        while (numLocal-- > 0) {
            int localType = localTypes[i];
            i += (localType == LONG || localType == DOUBLE) ? 2 : 1;
            methodWriter.visitAbstractType(frameIndex++, localType);
        }
        i = 0;
        while (numStack-- > 0) {
            int stackType = stackTypes[i];
            i += (stackType == LONG || stackType == DOUBLE) ? 2 : 1;
            methodWriter.visitAbstractType(frameIndex++, stackType);
        }
        methodWriter.visitFrameEnd();
    }

    /**
      * Put the given abstract type in the given ByteVector, using the JVMS verification_type_info
      * format used in StackMapTable attributes.
      *
      * @param symbolTable the type table to use to lookup and store type {@link Symbol}.
      * @param abstractType an abstract type, restricted to {@link Frame#CONSTANT_KIND}, {@link
      *     Frame#REFERENCE_KIND} or {@link Frame#UNINITIALIZED_KIND} types.
      * @param output where the abstract type must be put.
      * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.4">JVMS
      *     4.7.4</a>
      */
    static void putAbstractType(
            final SymbolTable symbolTable, final int abstractType, final ByteVector output) {
        int arrayDimensions = (abstractType & Frame.DIM_MASK) >> DIM_SHIFT;
        if (arrayDimensions == 0) {
            int typeValue = abstractType & VALUE_MASK;
            switch (abstractType & KIND_MASK) {
                case CONSTANT_KIND:
                    output.putByte(typeValue);
                    break;
                case REFERENCE_KIND:
                    output
                            .putByte(ITEM_OBJECT)
                            .putShort(symbolTable.addConstantClass(symbolTable.getType(typeValue).value).index);
                    break;
                case UNINITIALIZED_KIND:
                    output.putByte(ITEM_UNINITIALIZED).putShort((int) symbolTable.getType(typeValue).data);
                    break;
                default:
                    throw new AssertionError();
            }
        } else {
            // Case of an array type, we need to build its descriptor first.
            StringBuilder typeDescriptor = new StringBuilder();
            while (arrayDimensions-- > 0) {
                typeDescriptor.append('[');
            }
            if ((abstractType & KIND_MASK) == REFERENCE_KIND) {
                typeDescriptor
                        .append('L')
                        .append(symbolTable.getType(abstractType & VALUE_MASK).value)
                        .append(';');
            } else {
                switch (abstractType & VALUE_MASK) {
                    case Frame.ITEM_ASM_BOOLEAN:
                        typeDescriptor.append('Z');
                        break;
                    case Frame.ITEM_ASM_BYTE:
                        typeDescriptor.append('B');
                        break;
                    case Frame.ITEM_ASM_CHAR:
                        typeDescriptor.append('C');
                        break;
                    case Frame.ITEM_ASM_SHORT:
                        typeDescriptor.append('S');
                        break;
                    case Frame.ITEM_INTEGER:
                        typeDescriptor.append('I');
                        break;
                    case Frame.ITEM_FLOAT:
                        typeDescriptor.append('F');
                        break;
                    case Frame.ITEM_LONG:
                        typeDescriptor.append('J');
                        break;
                    case Frame.ITEM_DOUBLE:
                        typeDescriptor.append('D');
                        break;
                    default:
                        throw new AssertionError();
                }
            }
            output
                    .putByte(ITEM_OBJECT)
                    .putShort(symbolTable.addConstantClass(typeDescriptor.toString()).index);
        }
    }
}
