/*

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

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

/**

 * A parser to make a {@link ClassVisitor} visit a ClassFile structure, as defined in the Java

 * Virtual Machine Specification (JVMS). This class parses the ClassFile content and calls the

 * appropriate visit methods of a given {@link ClassVisitor} for each field, method and bytecode

 * instruction encountered.

 *

 * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html">JVMS 4</a>

 * @author Eric Bruneton

 * @author Eugene Kuleshov

 */

public class ClassReader {

    /**

      * A flag to skip the Code attributes. If this flag is set the Code attributes are neither parsed

      * nor visited.

      */

    public static final int SKIP_CODE = 1;

    /**

      * A flag to skip the SourceFile, SourceDebugExtension, LocalVariableTable, LocalVariableTypeTable

      * and LineNumberTable attributes. If this flag is set these attributes are neither parsed nor

      * visited (i.e. {@link ClassVisitor#visitSource}, {@link MethodVisitor#visitLocalVariable} and

      * {@link MethodVisitor#visitLineNumber} are not called).

      */

    public static final int SKIP_DEBUG = 2;

    /**

      * A flag to skip the StackMap and StackMapTable attributes. If this flag is set these attributes

      * are neither parsed nor visited (i.e. {@link MethodVisitor#visitFrame} is not called). This flag

      * is useful when the {@link ClassWriter#COMPUTE_FRAMES} option is used: it avoids visiting frames

      * that will be ignored and recomputed from scratch.

      */

    public static final int SKIP_FRAMES = 4;

    /**

      * A flag to expand the stack map frames. By default stack map frames are visited in their

      * original format (i.e. "expanded" for classes whose version is less than V1_6, and "compressed"

      * for the other classes). If this flag is set, stack map frames are always visited in expanded

      * format (this option adds a decompression/compression step in ClassReader and ClassWriter which

      * degrades performance quite a lot).

      */

    public static final int EXPAND_FRAMES = 8;

    /**

      * A flag to expand the ASM specific instructions into an equivalent sequence of standard bytecode

      * instructions. When resolving a forward jump it may happen that the signed 2 bytes offset

      * reserved for it is not sufficient to store the bytecode offset. In this case the jump

      * instruction is replaced with a temporary ASM specific instruction using an unsigned 2 bytes

      * offset (see {@link Label#resolve}). This internal flag is used to re-read classes containing

      * such instructions, in order to replace them with standard instructions. In addition, when this

      * flag is used, goto_w and jsr_w are <i>not</i> converted into goto and jsr, to make sure that

      * infinite loops where a goto_w is replaced with a goto in ClassReader and converted back to a

      * goto_w in ClassWriter cannot occur.

      */

    static final int EXPAND_ASM_INSNS = 256;

    /** The size of the temporary byte array used to read class input streams chunk by chunk. */

    private static final int INPUT_STREAM_DATA_CHUNK_SIZE = 4096;

    /**

      * A byte array containing the JVMS ClassFile structure to be parsed. <i>The content of this array

      * must not be modified. This field is intended for {@link Attribute} sub classes, and is normally

      * not needed by class visitors.</i>

      *

      * <p>NOTE: the ClassFile structure can start at any offset within this array, i.e. it does not

      * necessarily start at offset 0. Use {@link #getItem} and {@link #header} to get correct

      * ClassFile element offsets within this byte array.

      */

    // DontCheck(MemberName): can't be renamed (for backward binary compatibility).

    public final byte[] b;

    /**

      * The offset in bytes, in {@link #b}, of each cp_info entry of the ClassFile's constant_pool

      * array, <i>plus one</i>. In other words, the offset of constant pool entry i is given by

      * cpInfoOffsets[i] - 1, i.e. its cp_info's tag field is given by b[cpInfoOffsets[i] - 1].

      */

    private final int[] cpInfoOffsets;

    /**

      * The String objects corresponding to the CONSTANT_Utf8 constant pool items. This cache avoids

      * multiple parsing of a given CONSTANT_Utf8 constant pool item.

      */

    private final String[] constantUtf8Values;

    /**

      * The ConstantDynamic objects corresponding to the CONSTANT_Dynamic constant pool items. This

      * cache avoids multiple parsing of a given CONSTANT_Dynamic constant pool item.

      */

    private final ConstantDynamic[] constantDynamicValues;

    /**

      * The start offsets in {@link #b} of each element of the bootstrap_methods array (in the

      * BootstrapMethods attribute).

      *

      * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.23">JVMS

      *     4.7.23</a>

      */

    private final int[] bootstrapMethodOffsets;

    /**

      * A conservative estimate of the maximum length of the strings contained in the constant pool of

      * the class.

      */

    private final int maxStringLength;

    /** The offset in bytes, in {@link #b}, of the ClassFile's access_flags field. */

    public final int header;

    // -----------------------------------------------------------------------------------------------

    // Constructors

    // -----------------------------------------------------------------------------------------------

    /**

      * Constructs a new {@link ClassReader} object.

      *

      * @param classFile the JVMS ClassFile structure to be read.

      */

    public ClassReader(final byte[] classFile) {

        this(classFile, 0, classFile.length);

    }

    /**

      * Constructs a new {@link ClassReader} object.

      *

      * @param classFileBuffer a byte array containing the JVMS ClassFile structure to be read.

      * @param classFileOffset the offset in byteBuffer of the first byte of the ClassFile to be read.

      * @param classFileLength the length in bytes of the ClassFile to be read.

      */

    public ClassReader(

            final byte[] classFileBuffer,

            final int classFileOffset,

            final int classFileLength) { // NOPMD(UnusedFormalParameter) used for backward compatibility.

        this(classFileBuffer, classFileOffset, /* checkClassVersion = */ true);

    }

    /**

      * Constructs a new {@link ClassReader} object. <i>This internal constructor must not be exposed

      * as a public API</i>.

      *

      * @param classFileBuffer a byte array containing the JVMS ClassFile structure to be read.

      * @param classFileOffset the offset in byteBuffer of the first byte of the ClassFile to be read.

      * @param checkClassVersion whether to check the class version or not.

      */

    ClassReader(

            final byte[] classFileBuffer, final int classFileOffset, final boolean checkClassVersion) {

        b = classFileBuffer;

        // Check the class' major_version. This field is after the magic and minor_version fields, which

        // use 4 and 2 bytes respectively.

            throw new IllegalArgumentException(

                    "Unsupported class file major version " + readShort(classFileOffset + 6));

        }

        // Create the constant pool arrays. The constant_pool_count field is after the magic,

        // minor_version and major_version fields, which use 4, 2 and 2 bytes respectively.

        int constantPoolCount = readUnsignedShort(classFileOffset + 8);

        cpInfoOffsets = new int[constantPoolCount];

        constantUtf8Values = new String[constantPoolCount];

        // Compute the offset of each constant pool entry, as well as a conservative estimate of the

        // maximum length of the constant pool strings. The first constant pool entry is after the

        // magic, minor_version, major_version and constant_pool_count fields, which use 4, 2, 2 and 2

        // bytes respectively.

        int currentCpInfoIndex = 1;

        int currentCpInfoOffset = classFileOffset + 10;

        int currentMaxStringLength = 0;

        boolean hasConstantDynamic = false;

        boolean hasConstantInvokeDynamic = false;

        // The offset of the other entries depend on the total size of all the previous entries.

        while (currentCpInfoIndex < constantPoolCount) {

            cpInfoOffsets[currentCpInfoIndex++] = currentCpInfoOffset + 1;

            int cpInfoSize;

            switch (classFileBuffer[currentCpInfoOffset]) {

                case Symbol.CONSTANT_FIELDREF_TAG:

                case Symbol.CONSTANT_METHODREF_TAG:

                case Symbol.CONSTANT_INTERFACE_METHODREF_TAG:

                case Symbol.CONSTANT_INTEGER_TAG:

                case Symbol.CONSTANT_FLOAT_TAG:

                case Symbol.CONSTANT_NAME_AND_TYPE_TAG:

                    cpInfoSize = 5;

                    break;

                case Symbol.CONSTANT_DYNAMIC_TAG:

                    cpInfoSize = 5;

                    hasConstantDynamic = true;

                    break;

                case Symbol.CONSTANT_INVOKE_DYNAMIC_TAG:

                    cpInfoSize = 5;

                    hasConstantInvokeDynamic = true;

                    break;

                case Symbol.CONSTANT_LONG_TAG:

                case Symbol.CONSTANT_DOUBLE_TAG:

                    cpInfoSize = 9;

                    currentCpInfoIndex++;

                    break;

                case Symbol.CONSTANT_UTF8_TAG:

                    cpInfoSize = 3 + readUnsignedShort(currentCpInfoOffset + 1);

                    if (cpInfoSize > currentMaxStringLength) {

                        // The size in bytes of this CONSTANT_Utf8 structure provides a conservative estimate

                        // of the length in characters of the corresponding string, and is much cheaper to

                        // compute than this exact length.

                        currentMaxStringLength = cpInfoSize;

                    }

                    break;

                case Symbol.CONSTANT_METHOD_HANDLE_TAG:

                    cpInfoSize = 4;

                    break;

                case Symbol.CONSTANT_CLASS_TAG:

                case Symbol.CONSTANT_STRING_TAG:

                case Symbol.CONSTANT_METHOD_TYPE_TAG:

                case Symbol.CONSTANT_PACKAGE_TAG:

                case Symbol.CONSTANT_MODULE_TAG:

                    cpInfoSize = 3;

                    break;

                default:

                    throw new IllegalArgumentException();

            }

            currentCpInfoOffset += cpInfoSize;

        }

        maxStringLength = currentMaxStringLength;

        // The Classfile's access_flags field is just after the last constant pool entry.

        header = currentCpInfoOffset;

        // Allocate the cache of ConstantDynamic values, if there is at least one.

        constantDynamicValues = hasConstantDynamic ? new ConstantDynamic[constantPoolCount] : null;

        // Read the BootstrapMethods attribute, if any (only get the offset of each method).

        bootstrapMethodOffsets =

                (hasConstantDynamic | hasConstantInvokeDynamic)

                        ? readBootstrapMethodsAttribute(currentMaxStringLength)

                        : null;

    }

    /**

      * Constructs a new {@link ClassReader} object.

      *

      * @param inputStream an input stream of the JVMS ClassFile structure to be read. This input

      *     stream must contain nothing more than the ClassFile structure itself. It is read from its

      *     current position to its end.

      * @throws IOException if a problem occurs during reading.

      */

    public ClassReader(final InputStream inputStream) throws IOException {

        this(readStream(inputStream, false));

    }

    /**

      * Constructs a new {@link ClassReader} object.

      *

      * @param className the fully qualified name of the class to be read. The ClassFile structure is

      *     retrieved with the current class loader's {@link ClassLoader#getSystemResourceAsStream}.

      * @throws IOException if an exception occurs during reading.

      */

    public ClassReader(final String className) throws IOException {

        this(

                readStream(

                        ClassLoader.getSystemResourceAsStream(className.replace('.', '/') + ".class"), true));

    }

    /**

      * Reads the given input stream and returns its content as a byte array.

      *

      * @param inputStream an input stream.

      * @param close true to close the input stream after reading.

      * @return the content of the given input stream.

      * @throws IOException if a problem occurs during reading.

      */

    private static byte[] readStream(final InputStream inputStream, final boolean close)

            throws IOException {

        if (inputStream == null) {

            throw new IOException("Class not found");

        }

        try {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            byte[] data = new byte[INPUT_STREAM_DATA_CHUNK_SIZE];

            int bytesRead;

            while ((bytesRead = inputStream.read(data, 0, data.length)) != -1) {

                outputStream.write(data, 0, bytesRead);

            }

            outputStream.flush();

            return outputStream.toByteArray();

        } finally {

            if (close) {

                inputStream.close();

            }

        }

    }

    // -----------------------------------------------------------------------------------------------

    // Accessors

    // -----------------------------------------------------------------------------------------------

    /**

      * Returns the class's access flags (see {@link Opcodes}). This value may not reflect Deprecated

      * and Synthetic flags when bytecode is before 1.5 and those flags are represented by attributes.

      *

      * @return the class access flags.

      * @see ClassVisitor#visit(int, int, String, String, String, String[])

      */

    public int getAccess() {

        return readUnsignedShort(header);

    }

    /**

      * Returns the internal name of the class (see {@link Type#getInternalName()}).

      *

      * @return the internal class name.

      * @see ClassVisitor#visit(int, int, String, String, String, String[])

      */

    public String getClassName() {

        // this_class is just after the access_flags field (using 2 bytes).

        return readClass(header + 2, new char[maxStringLength]);

    }

    /**

      * Returns the internal of name of the super class (see {@link Type#getInternalName()}). For

      * interfaces, the super class is {@link Object}.

      *

      * @return the internal name of the super class, or {@literal null} for {@link Object} class.

      * @see ClassVisitor#visit(int, int, String, String, String, String[])

      */

    public String getSuperName() {

        // super_class is after the access_flags and this_class fields (2 bytes each).

        return readClass(header + 4, new char[maxStringLength]);

    }

    /**

      * Returns the internal names of the implemented interfaces (see {@link Type#getInternalName()}).

      *

      * @return the internal names of the directly implemented interfaces. Inherited implemented

      *     interfaces are not returned.

      * @see ClassVisitor#visit(int, int, String, String, String, String[])

      */

    public String[] getInterfaces() {

        // interfaces_count is after the access_flags, this_class and super_class fields (2 bytes each).

        int currentOffset = header + 6;

        int interfacesCount = readUnsignedShort(currentOffset);

        String[] interfaces = new String[interfacesCount];

        if (interfacesCount > 0) {

            char[] charBuffer = new char[maxStringLength];

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

                currentOffset += 2;

                interfaces[i] = readClass(currentOffset, charBuffer);

            }

        }

        return interfaces;

    }

    // -----------------------------------------------------------------------------------------------

    // Public methods

    // -----------------------------------------------------------------------------------------------

    /**

      * Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this

      * {@link ClassReader}.

      *

      * @param classVisitor the visitor that must visit this class.

      * @param parsingOptions the options to use to parse this class. One or more of {@link

      *     #SKIP_CODE}, {@link #SKIP_DEBUG}, {@link #SKIP_FRAMES} or {@link #EXPAND_FRAMES}.

      */

    public void accept(final ClassVisitor classVisitor, final int parsingOptions) {

        accept(classVisitor, new Attribute[0], parsingOptions);

    }

    /**

      * Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this

      * {@link ClassReader}.

      *

      * @param classVisitor the visitor that must visit this class.

      * @param attributePrototypes prototypes of the attributes that must be parsed during the visit of

      *     the class. Any attribute whose type is not equal to the type of one the prototypes will not

      *     be parsed: its byte array value will be passed unchanged to the ClassWriter. <i>This may

      *     corrupt it if this value contains references to the constant pool, or has syntactic or

      *     semantic links with a class element that has been transformed by a class adapter between

      *     the reader and the writer</i>.

      * @param parsingOptions the options to use to parse this class. One or more of {@link

      *     #SKIP_CODE}, {@link #SKIP_DEBUG}, {@link #SKIP_FRAMES} or {@link #EXPAND_FRAMES}.

      */

    public void accept(

            final ClassVisitor classVisitor,

            final Attribute[] attributePrototypes,

            final int parsingOptions) {

        Context context = new Context();

        context.attributePrototypes = attributePrototypes;

        context.parsingOptions = parsingOptions;

        context.charBuffer = new char[maxStringLength];

        // Read the access_flags, this_class, super_class, interface_count and interfaces fields.

        char[] charBuffer = context.charBuffer;

        int currentOffset = header;

        int accessFlags = readUnsignedShort(currentOffset);

        String thisClass = readClass(currentOffset + 2, charBuffer);

        String superClass = readClass(currentOffset + 4, charBuffer);

        String[] interfaces = new String[readUnsignedShort(currentOffset + 6)];

        currentOffset += 8;

        for (int i = 0; i < interfaces.length; ++i) {

            interfaces[i] = readClass(currentOffset, charBuffer);

            currentOffset += 2;

        }

        // Read the class attributes (the variables are ordered as in Section 4.7 of the JVMS).

        // Attribute offsets exclude the attribute_name_index and attribute_length fields.

        // - The offset of the InnerClasses attribute, or 0.

        int innerClassesOffset = 0;

        // - The offset of the EnclosingMethod attribute, or 0.

        int enclosingMethodOffset = 0;

        // - The string corresponding to the Signature attribute, or null.

        String signature = null;

        // - The string corresponding to the SourceFile attribute, or null.

        String sourceFile = null;

        // - The string corresponding to the SourceDebugExtension attribute, or null.

        String sourceDebugExtension = null;

        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.

        int runtimeVisibleAnnotationsOffset = 0;

        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.

        int runtimeInvisibleAnnotationsOffset = 0;

        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.

        int runtimeVisibleTypeAnnotationsOffset = 0;

        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.

        int runtimeInvisibleTypeAnnotationsOffset = 0;

        // - The offset of the Module attribute, or 0.

        int moduleOffset = 0;

        // - The offset of the ModulePackages attribute, or 0.

        int modulePackagesOffset = 0;

        // - The string corresponding to the ModuleMainClass attribute, or null.

        String moduleMainClass = null;

        // - The string corresponding to the NestHost attribute, or null.

        String nestHostClass = null;

        // - The offset of the NestMembers attribute, or 0.

        int nestMembersOffset = 0;

        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).

        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.

        Attribute attributes = null;

        int currentAttributeOffset = getFirstAttributeOffset();

        for (int i = readUnsignedShort(currentAttributeOffset - 2); i > 0; --i) {

            // Read the attribute_info's attribute_name and attribute_length fields.

            String attributeName = readUTF8(currentAttributeOffset, charBuffer);

            int attributeLength = readInt(currentAttributeOffset + 2);

            currentAttributeOffset += 6;