Subversion Repositories openrisc

/***

 * ASM: a very small and fast Java bytecode manipulation framework

 * Copyright (c) 2000-2005 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 org.objectweb.asm.util;

import org.objectweb.asm.AnnotationVisitor;

import org.objectweb.asm.Label;

import org.objectweb.asm.MethodAdapter;

import org.objectweb.asm.MethodVisitor;

import org.objectweb.asm.Opcodes;

import org.objectweb.asm.Attribute;

import org.objectweb.asm.Type;

import java.util.HashMap;

/**

 * A {@link MethodAdapter} that checks that its methods are properly used. More

 * precisely this code adapter checks each instruction individually (i.e., each

 * visit method checks some preconditions based <i>only</i> on its arguments -

 * such as the fact that the given opcode is correct for a given visit method),

 * but does <i>not</i> check the <i>sequence</i> of instructions. For example,

 * in a method whose signature is <tt>void m ()</tt>, the invalid instruction

 * IRETURN, or the invalid sequence IADD L2I will <i>not</i> be detected by

 * this code adapter.

 *

 * @author Eric Bruneton

 */

public class CheckMethodAdapter extends MethodAdapter {

    /**

     * <tt>true</tt> if the visitCode method has been called.

     */

    private boolean startCode;

    /**

     * <tt>true</tt> if the visitMaxs method has been called.

     */

    private boolean endCode;

    /**

     * <tt>true</tt> if the visitEnd method has been called.

     */

    private boolean endMethod;

    /**

     * The already visited labels. This map associate Integer values to Label

     * keys.

     */

    private HashMap labels;

    /**

     * Code of the visit method to be used for each opcode.

     */

    private final static int[] TYPE;

    static {

        String s = "BBBBBBBBBBBBBBBBCCIAADDDDDAAAAAAAAAAAAAAAAAAAABBBBBBBBDD"

                + "DDDAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"

                + "BBBBBBBBBBBBBBBBBBBJBBBBBBBBBBBBBBBBBBBBHHHHHHHHHHHHHHHHD"

                + "KLBBBBBBFFFFGGGGAECEBBEEBBAMHHAA";

        TYPE = new int[s.length()];

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

            TYPE[i] = (s.charAt(i) - 'A' - 1);

        }

    }

    // code to generate the above string

    // public static void main (String[] args) {

    // int[] TYPE = new int[] {

    // 0, //NOP

    // 0, //ACONST_NULL

    // 0, //ICONST_M1

    // 0, //ICONST_0

    // 0, //ICONST_1

    // 0, //ICONST_2

    // 0, //ICONST_3

    // 0, //ICONST_4

    // 0, //ICONST_5

    // 0, //LCONST_0

    // 0, //LCONST_1

    // 0, //FCONST_0

    // 0, //FCONST_1

    // 0, //FCONST_2

    // 0, //DCONST_0

    // 0, //DCONST_1

    // 1, //BIPUSH

    // 1, //SIPUSH

    // 7, //LDC

    // -1, //LDC_W

    // -1, //LDC2_W

    // 2, //ILOAD

    // 2, //LLOAD

    // 2, //FLOAD

    // 2, //DLOAD

    // 2, //ALOAD

    // -1, //ILOAD_0

    // -1, //ILOAD_1

    // -1, //ILOAD_2

    // -1, //ILOAD_3

    // -1, //LLOAD_0

    // -1, //LLOAD_1

    // -1, //LLOAD_2

    // -1, //LLOAD_3

    // -1, //FLOAD_0

    // -1, //FLOAD_1

    // -1, //FLOAD_2

    // -1, //FLOAD_3

    // -1, //DLOAD_0

    // -1, //DLOAD_1

    // -1, //DLOAD_2

    // -1, //DLOAD_3

    // -1, //ALOAD_0

    // -1, //ALOAD_1

    // -1, //ALOAD_2

    // -1, //ALOAD_3

    // 0, //IALOAD

    // 0, //LALOAD

    // 0, //FALOAD

    // 0, //DALOAD

    // 0, //AALOAD

    // 0, //BALOAD

    // 0, //CALOAD

    // 0, //SALOAD

    // 2, //ISTORE

    // 2, //LSTORE

    // 2, //FSTORE

    // 2, //DSTORE

    // 2, //ASTORE

    // -1, //ISTORE_0

    // -1, //ISTORE_1

    // -1, //ISTORE_2

    // -1, //ISTORE_3

    // -1, //LSTORE_0

    // -1, //LSTORE_1

    // -1, //LSTORE_2

    // -1, //LSTORE_3

    // -1, //FSTORE_0

    // -1, //FSTORE_1

    // -1, //FSTORE_2

    // -1, //FSTORE_3

    // -1, //DSTORE_0

    // -1, //DSTORE_1

    // -1, //DSTORE_2

    // -1, //DSTORE_3

    // -1, //ASTORE_0

    // -1, //ASTORE_1

    // -1, //ASTORE_2

    // -1, //ASTORE_3

    // 0, //IASTORE

    // 0, //LASTORE

    // 0, //FASTORE

    // 0, //DASTORE

    // 0, //AASTORE

    // 0, //BASTORE

    // 0, //CASTORE

    // 0, //SASTORE

    // 0, //POP

    // 0, //POP2

    // 0, //DUP

    // 0, //DUP_X1

    // 0, //DUP_X2

    // 0, //DUP2

    // 0, //DUP2_X1

    // 0, //DUP2_X2

    // 0, //SWAP

    // 0, //IADD

    // 0, //LADD

    // 0, //FADD

    // 0, //DADD

    // 0, //ISUB

    // 0, //LSUB

    // 0, //FSUB

    // 0, //DSUB

    // 0, //IMUL

    // 0, //LMUL

    // 0, //FMUL

    // 0, //DMUL

    // 0, //IDIV

    // 0, //LDIV

    // 0, //FDIV

    // 0, //DDIV

    // 0, //IREM

    // 0, //LREM

    // 0, //FREM

    // 0, //DREM

    // 0, //INEG

    // 0, //LNEG

    // 0, //FNEG

    // 0, //DNEG

    // 0, //ISHL

    // 0, //LSHL

    // 0, //ISHR

    // 0, //LSHR

    // 0, //IUSHR

    // 0, //LUSHR

    // 0, //IAND

    // 0, //LAND

    // 0, //IOR

    // 0, //LOR

    // 0, //IXOR

    // 0, //LXOR

    // 8, //IINC

    // 0, //I2L

    // 0, //I2F

    // 0, //I2D

    // 0, //L2I

    // 0, //L2F

    // 0, //L2D

    // 0, //F2I

    // 0, //F2L

    // 0, //F2D

    // 0, //D2I

    // 0, //D2L

    // 0, //D2F

    // 0, //I2B

    // 0, //I2C

    // 0, //I2S

    // 0, //LCMP

    // 0, //FCMPL

    // 0, //FCMPG

    // 0, //DCMPL

    // 0, //DCMPG

    // 6, //IFEQ

    // 6, //IFNE

    // 6, //IFLT

    // 6, //IFGE

    // 6, //IFGT

    // 6, //IFLE

    // 6, //IF_ICMPEQ

    // 6, //IF_ICMPNE

    // 6, //IF_ICMPLT

    // 6, //IF_ICMPGE

    // 6, //IF_ICMPGT

    // 6, //IF_ICMPLE

    // 6, //IF_ACMPEQ

    // 6, //IF_ACMPNE

    // 6, //GOTO

    // 6, //JSR

    // 2, //RET

    // 9, //TABLESWITCH

    // 10, //LOOKUPSWITCH

    // 0, //IRETURN

    // 0, //LRETURN

    // 0, //FRETURN

    // 0, //DRETURN

    // 0, //ARETURN

    // 0, //RETURN

    // 4, //GETSTATIC

    // 4, //PUTSTATIC

    // 4, //GETFIELD

    // 4, //PUTFIELD

    // 5, //INVOKEVIRTUAL

    // 5, //INVOKESPECIAL

    // 5, //INVOKESTATIC

    // 5, //INVOKEINTERFACE

    // -1, //UNUSED

    // 3, //NEW

    // 1, //NEWARRAY

    // 3, //ANEWARRAY

    // 0, //ARRAYLENGTH

    // 0, //ATHROW

    // 3, //CHECKCAST

    // 3, //INSTANCEOF

    // 0, //MONITORENTER

    // 0, //MONITOREXIT

    // -1, //WIDE

    // 11, //MULTIANEWARRAY

    // 6, //IFNULL

    // 6, //IFNONNULL

    // -1, //GOTO_W

    // -1 //JSR_W

    // };

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

    // System.out.print((char)(TYPE[i] + 1 + 'A'));

    // }

    // System.out.println();

    // }

    /**

     * Constructs a new {@link CheckMethodAdapter} object.

     *

     * @param cv the code visitor to which this adapter must delegate calls.

     */

    public CheckMethodAdapter(final MethodVisitor cv) {

        super(cv);

        this.labels = new HashMap();

    }

    public AnnotationVisitor visitAnnotation(

        final String desc,

        final boolean visible)

    {

        checkEndMethod();

        checkDesc(desc, false);

        return new CheckAnnotationAdapter(mv.visitAnnotation(desc, visible));

    }

    public AnnotationVisitor visitAnnotationDefault() {

        checkEndMethod();

        return new CheckAnnotationAdapter(mv.visitAnnotationDefault(), false);

    }

    public AnnotationVisitor visitParameterAnnotation(

        final int parameter,

        final String desc,

        final boolean visible)

    {

        checkEndMethod();

        checkDesc(desc, false);

        return new CheckAnnotationAdapter(mv.visitParameterAnnotation(parameter,

                desc,

                visible));

    }

    public void visitAttribute(final Attribute attr) {

        checkEndMethod();

        if (attr == null) {

            throw new IllegalArgumentException("Invalid attribute (must not be null)");

        }

        mv.visitAttribute(attr);

    }

    public void visitCode() {

        startCode = true;

        mv.visitCode();

    }

    public void visitInsn(final int opcode) {

        checkStartCode();

        checkEndCode();

        checkOpcode(opcode, 0);

        mv.visitInsn(opcode);

    }

    public void visitIntInsn(final int opcode, final int operand) {

        checkStartCode();

        checkEndCode();

        checkOpcode(opcode, 1);

        switch (opcode) {

            case Opcodes.BIPUSH:

                checkSignedByte(operand, "Invalid operand");

                break;

            case Opcodes.SIPUSH:

                checkSignedShort(operand, "Invalid operand");

                break;

            // case Constants.NEWARRAY:

            default:

                if (operand < Opcodes.T_BOOLEAN || operand > Opcodes.T_LONG) {

                    throw new IllegalArgumentException("Invalid operand (must be an array type code T_...): "

                            + operand);

                }

        }

        mv.visitIntInsn(opcode, operand);

    }

    public void visitVarInsn(final int opcode, final int var) {

        checkStartCode();

        checkEndCode();

        checkOpcode(opcode, 2);

        checkUnsignedShort(var, "Invalid variable index");

        mv.visitVarInsn(opcode, var);

    }

    public void visitTypeInsn(final int opcode, final String desc) {

        checkStartCode();

        checkEndCode();

        checkOpcode(opcode, 3);

        if (desc != null && desc.length() > 0 && desc.charAt(0) == '[') {

            checkDesc(desc, false);

        } else {

            checkInternalName(desc, "type");

        }

        if (opcode == Opcodes.NEW && desc.charAt(0) == '[') {

            throw new IllegalArgumentException("NEW cannot be used to create arrays: "

                    + desc);

        }

        mv.visitTypeInsn(opcode, desc);

    }

    public void visitFieldInsn(

        final int opcode,

        final String owner,

        final String name,

        final String desc)

    {

        checkStartCode();

        checkEndCode();

        checkOpcode(opcode, 4);

        checkInternalName(owner, "owner");

        checkIdentifier(name, "name");

        checkDesc(desc, false);

        mv.visitFieldInsn(opcode, owner, name, desc);

    }

    public void visitMethodInsn(

        final int opcode,

        final String owner,

        final String name,

        final String desc)

    {

        checkStartCode();

        checkEndCode();

        checkOpcode(opcode, 5);

        checkMethodIdentifier(name, "name");

        if (!name.equals("clone")) {

            // In JDK1.5, clone method can be called on array class descriptors

            checkInternalName(owner, "owner");

        }

        checkMethodDesc(desc);

        mv.visitMethodInsn(opcode, owner, name, desc);

    }

    public void visitJumpInsn(final int opcode, final Label label) {

        checkStartCode();

        checkEndCode();

        checkOpcode(opcode, 6);

        checkLabel(label, false, "label");

        mv.visitJumpInsn(opcode, label);

    }

    public void visitLabel(final Label label) {

        checkStartCode();

        checkEndCode();

        checkLabel(label, false, "label");

        if (labels.get(label) != null) {

            throw new IllegalArgumentException("Already visited label");

        } else {

            labels.put(label, new Integer(labels.size()));

        }

        mv.visitLabel(label);

    }

    public void visitLdcInsn(final Object cst) {

        checkStartCode();

        checkEndCode();

        if (!(cst instanceof Type)) {

            checkConstant(cst);

        }

        mv.visitLdcInsn(cst);

    }

    public void visitIincInsn(final int var, final int increment) {

        checkStartCode();

        checkEndCode();

        checkUnsignedShort(var, "Invalid variable index");

        checkSignedShort(increment, "Invalid increment");

        mv.visitIincInsn(var, increment);

    }

    public void visitTableSwitchInsn(

        final int min,

        final int max,

        final Label dflt,

        final Label labels[])

    {

        checkStartCode();

        checkEndCode();

        if (max < min) {

            throw new IllegalArgumentException("Max = " + max

                    + " must be greater than or equal to min = " + min);

        }

        checkLabel(dflt, false, "default label");

        if (labels == null || labels.length != max - min + 1) {

            throw new IllegalArgumentException("There must be max - min + 1 labels");

        }

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

            checkLabel(labels[i], false, "label at index " + i);

        }

        mv.visitTableSwitchInsn(min, max, dflt, labels);

    }

    public void visitLookupSwitchInsn(

        final Label dflt,

        final int keys[],

        final Label labels[])

    {

        checkEndCode();

        checkStartCode();

        checkLabel(dflt, false, "default label");

        if (keys == null || labels == null || keys.length != labels.length) {

            throw new IllegalArgumentException("There must be the same number of keys and labels");

       }

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

            checkLabel(labels[i], false, "label at index " + i);

        }

        mv.visitLookupSwitchInsn(dflt, keys, labels);

    }

    public void visitMultiANewArrayInsn(final String desc, final int dims) {

        checkStartCode();

        checkEndCode();

        checkDesc(desc, false);

        if (desc.charAt(0) != '[') {

            throw new IllegalArgumentException("Invalid descriptor (must be an array type descriptor): "

                    + desc);

        }

        if (dims < 1) {

            throw new IllegalArgumentException("Invalid dimensions (must be greater than 0): "

                    + dims);

        }

        if (dims > desc.lastIndexOf('[') + 1) {

            throw new IllegalArgumentException("Invalid dimensions (must not be greater than dims(desc)): "

                    + dims);

        }

        mv.visitMultiANewArrayInsn(desc, dims);

    }

    public void visitTryCatchBlock(

        final Label start,

        final Label end,

        final Label handler,

        final String type)

    {

        checkStartCode();

        checkEndCode();

        if (type != null) {

            checkInternalName(type, "type");

        }

        mv.visitTryCatchBlock(start, end, handler, type);

    }

    public void visitLocalVariable(

        final String name,

        final String desc,

        final String signature,

        final Label start,

        final Label end,

        final int index)

    {

        checkStartCode();

        checkEndCode();

        checkIdentifier(name, "name");

        checkDesc(desc, false);

        checkLabel(start, true, "start label");

        checkLabel(end, true, "end label");

        checkUnsignedShort(index, "Invalid variable index");

        int s = ((Integer) labels.get(start)).intValue();

        int e = ((Integer) labels.get(end)).intValue();

        if (e < s) {

            throw new IllegalArgumentException("Invalid start and end labels (end must be greater than start)");

        }

        mv.visitLocalVariable(name, desc, signature, start, end, index);

    }

    public void visitLineNumber(final int line, final Label start) {

        checkStartCode();

        checkEndCode();

        checkUnsignedShort(line, "Invalid line number");

        checkLabel(start, true, "start label");

        mv.visitLineNumber(line, start);

    }

    public void visitMaxs(final int maxStack, final int maxLocals) {

        checkStartCode();

        checkEndCode();

        endCode = true;

        checkUnsignedShort(maxStack, "Invalid max stack");

        checkUnsignedShort(maxLocals, "Invalid max locals");

        mv.visitMaxs(maxStack, maxLocals);

    }

    public void visitEnd() {

        checkEndMethod();

        endMethod = true;

        mv.visitEnd();

    }

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

    /**

     * Checks that the visitCode method has been called.

     */

    void checkStartCode() {

        if (!startCode) {

            throw new IllegalStateException("Cannot visit instructions before visitCode has been called.");

        }

    }

    /**

     * Checks that the visitMaxs method has not been called.

     */

    void checkEndCode() {

        if (endCode) {

            throw new IllegalStateException("Cannot visit instructions after visitMaxs has been called.");

        }

    }

    /**

     * Checks that the visitEnd method has not been called.

     */

    void checkEndMethod() {

        if (endMethod) {

            throw new IllegalStateException("Cannot visit elements after visitEnd has been called.");

        }

    }

    /**

     * Checks that the type of the given opcode is equal to the given type.

     *

     * @param opcode the opcode to be checked.

     * @param type the expected opcode type.

     */

    static void checkOpcode(final int opcode, final int type) {

        if (opcode < 0 || opcode > 199 || TYPE[opcode] != type) {

            throw new IllegalArgumentException("Invalid opcode: " + opcode);

        }

    }

    /**

     * Checks that the given value is a signed byte.

     *

     * @param value the value to be checked.

     * @param msg an message to be used in case of error.

     */

    static void checkSignedByte(final int value, final String msg) {

        if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {

            throw new IllegalArgumentException(msg

                    + " (must be a signed byte): " + value);

        }

    }

    /**

     * Checks that the given value is a signed short.

     *

     * @param value the value to be checked.

     * @param msg an message to be used in case of error.

     */

    static void checkSignedShort(final int value, final String msg) {

        if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {

            throw new IllegalArgumentException(msg

                    + " (must be a signed short): " + value);

        }

    }

    /**

     * Checks that the given value is an unsigned short.

     *

     * @param value the value to be checked.

     * @param msg an message to be used in case of error.

     */

    static void checkUnsignedShort(final int value, final String msg) {

        if (value < 0 || value > 65535) {

            throw new IllegalArgumentException(msg

                    + " (must be an unsigned short): " + value);

        }

    }

    /**

     * Checks that the given value is an {@link Integer}, a{@link Float}, a

     * {@link Long}, a {@link Double} or a {@link String}.

     *

     * @param cst the value to be checked.

     */

    static void checkConstant(final Object cst) {

        if (!(cst instanceof Integer) && !(cst instanceof Float)

                && !(cst instanceof Long) && !(cst instanceof Double)

                && !(cst instanceof String))

        {

            throw new IllegalArgumentException("Invalid constant: " + cst);

        }

    }

    /**

     * Checks that the given string is a valid Java identifier.

     *

     * @param name the string to be checked.

     * @param msg a message to be used in case of error.

     */

    static void checkIdentifier(final String name, final String msg) {

        checkIdentifier(name, 0, -1, msg);

    }

    /**

     * Checks that the given substring is a valid Java identifier.

     *

     * @param name the string to be checked.

     * @param start index of the first character of the identifier (inclusive).

     * @param end index of the last character of the identifier (exclusive). -1

     *        is equivalent to <tt>name.length()</tt> if name is not