/*
 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.reflect;

import java.lang.reflect.*;
import sun.misc.Unsafe;

/** Shared functionality for all accessor generators */

class AccessorGenerator implements ClassFileConstants {
    static final Unsafe unsafe = Unsafe.getUnsafe();

    // Constants because there's no way to say "short integer constant",
    // i.e., "1S"
    protected static final short S0 = (short) 0;
    protected static final short S1 = (short) 1;
    protected static final short S2 = (short) 2;
    protected static final short S3 = (short) 3;
    protected static final short S4 = (short) 4;
    protected static final short S5 = (short) 5;
    protected static final short S6 = (short) 6;

    // Instance variables for shared functionality between
    // FieldAccessorGenerator and MethodAccessorGenerator
    protected ClassFileAssembler asm;
    protected int   modifiers;
    protected short thisClass;
    protected short superClass;
    protected short targetClass;
    // Common constant pool entries to FieldAccessor and MethodAccessor
    protected short throwableClass;
    protected short classCastClass;
    protected short nullPointerClass;
    protected short illegalArgumentClass;
    protected short invocationTargetClass;
    protected short initIdx;
    protected short initNameAndTypeIdx;
    protected short initStringNameAndTypeIdx;
    protected short nullPointerCtorIdx;
    protected short illegalArgumentCtorIdx;
    protected short illegalArgumentStringCtorIdx;
    protected short invocationTargetCtorIdx;
    protected short superCtorIdx;
    protected short objectClass;
    protected short toStringIdx;
    protected short codeIdx;
    protected short exceptionsIdx;
    // Boxing
    protected short booleanIdx;
    protected short booleanCtorIdx;
    protected short booleanUnboxIdx;
    protected short byteIdx;
    protected short byteCtorIdx;
    protected short byteUnboxIdx;
    protected short characterIdx;
    protected short characterCtorIdx;
    protected short characterUnboxIdx;
    protected short doubleIdx;
    protected short doubleCtorIdx;
    protected short doubleUnboxIdx;
    protected short floatIdx;
    protected short floatCtorIdx;
    protected short floatUnboxIdx;
    protected short integerIdx;
    protected short integerCtorIdx;
    protected short integerUnboxIdx;
    protected short longIdx;
    protected short longCtorIdx;
    protected short longUnboxIdx;
    protected short shortIdx;
    protected short shortCtorIdx;
    protected short shortUnboxIdx;

    protected final short NUM_COMMON_CPOOL_ENTRIES = (short) 30;
    protected final short NUM_BOXING_CPOOL_ENTRIES = (short) 72;

    // Requires that superClass has been set up
    protected void emitCommonConstantPoolEntries() {
        // +   [UTF-8] "java/lang/Throwable"
        // +   [CONSTANT_Class_info] for above
        // +   [UTF-8] "java/lang/ClassCastException"
        // +   [CONSTANT_Class_info] for above
        // +   [UTF-8] "java/lang/NullPointerException"
        // +   [CONSTANT_Class_info] for above
        // +   [UTF-8] "java/lang/IllegalArgumentException"
        // +   [CONSTANT_Class_info] for above
        // +   [UTF-8] "java/lang/InvocationTargetException"
        // +   [CONSTANT_Class_info] for above
        // +   [UTF-8] "<init>"
        // +   [UTF-8] "()V"
        // +   [CONSTANT_NameAndType_info] for above
        // +   [CONSTANT_Methodref_info] for NullPointerException's constructor
        // +   [CONSTANT_Methodref_info] for IllegalArgumentException's constructor
        // +   [UTF-8] "(Ljava/lang/String;)V"
        // +   [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/String;)V"
        // +   [CONSTANT_Methodref_info] for IllegalArgumentException's constructor taking a String
        // +   [UTF-8] "(Ljava/lang/Throwable;)V"
        // +   [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/Throwable;)V"
        // +   [CONSTANT_Methodref_info] for InvocationTargetException's constructor
        // +   [CONSTANT_Methodref_info] for "super()"
        // +   [UTF-8] "java/lang/Object"
        // +   [CONSTANT_Class_info] for above
        // +   [UTF-8] "toString"
        // +   [UTF-8] "()Ljava/lang/String;"
        // +   [CONSTANT_NameAndType_info] for "toString()Ljava/lang/String;"
        // +   [CONSTANT_Methodref_info] for Object's toString method
        // +   [UTF-8] "Code"
        // +   [UTF-8] "Exceptions"
        asm.emitConstantPoolUTF8("java/lang/Throwable");
        asm.emitConstantPoolClass(asm.cpi());
        throwableClass = asm.cpi();
        asm.emitConstantPoolUTF8("java/lang/ClassCastException");
        asm.emitConstantPoolClass(asm.cpi());
        classCastClass = asm.cpi();
        asm.emitConstantPoolUTF8("java/lang/NullPointerException");
        asm.emitConstantPoolClass(asm.cpi());
        nullPointerClass = asm.cpi();
        asm.emitConstantPoolUTF8("java/lang/IllegalArgumentException");
        asm.emitConstantPoolClass(asm.cpi());
        illegalArgumentClass = asm.cpi();
        asm.emitConstantPoolUTF8("java/lang/reflect/InvocationTargetException");
        asm.emitConstantPoolClass(asm.cpi());
        invocationTargetClass = asm.cpi();
        asm.emitConstantPoolUTF8("<init>");
        initIdx = asm.cpi();
        asm.emitConstantPoolUTF8("()V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        initNameAndTypeIdx = asm.cpi();
        asm.emitConstantPoolMethodref(nullPointerClass, initNameAndTypeIdx);
        nullPointerCtorIdx = asm.cpi();
        asm.emitConstantPoolMethodref(illegalArgumentClass, initNameAndTypeIdx);
        illegalArgumentCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(Ljava/lang/String;)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        initStringNameAndTypeIdx = asm.cpi();
        asm.emitConstantPoolMethodref(illegalArgumentClass, initStringNameAndTypeIdx);
        illegalArgumentStringCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(Ljava/lang/Throwable;)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(invocationTargetClass, asm.cpi());
        invocationTargetCtorIdx = asm.cpi();
        asm.emitConstantPoolMethodref(superClass, initNameAndTypeIdx);
        superCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("java/lang/Object");
        asm.emitConstantPoolClass(asm.cpi());
        objectClass = asm.cpi();
        asm.emitConstantPoolUTF8("toString");
        asm.emitConstantPoolUTF8("()Ljava/lang/String;");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(objectClass, asm.cpi());
        toStringIdx = asm.cpi();
        asm.emitConstantPoolUTF8("Code");
        codeIdx = asm.cpi();
        asm.emitConstantPoolUTF8("Exceptions");
        exceptionsIdx = asm.cpi();
    }

    /** Constant pool entries required to be able to box/unbox primitive
        types. Note that we don't emit these if we don't need them. */
    protected void emitBoxingContantPoolEntries() {
        //  *  [UTF-8] "java/lang/Boolean"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(Z)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "booleanValue"
        //  *  [UTF-8] "()Z"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "java/lang/Byte"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(B)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "byteValue"
        //  *  [UTF-8] "()B"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "java/lang/Character"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(C)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "charValue"
        //  *  [UTF-8] "()C"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "java/lang/Double"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(D)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "doubleValue"
        //  *  [UTF-8] "()D"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "java/lang/Float"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(F)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "floatValue"
        //  *  [UTF-8] "()F"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "java/lang/Integer"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(I)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "intValue"
        //  *  [UTF-8] "()I"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "java/lang/Long"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(J)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "longValue"
        //  *  [UTF-8] "()J"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "java/lang/Short"
        //  *  [CONSTANT_Class_info] for above
        //  *  [UTF-8] "(S)V"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        //  *  [UTF-8] "shortValue"
        //  *  [UTF-8] "()S"
        //  *  [CONSTANT_NameAndType_info] for above
        //  *  [CONSTANT_Methodref_info] for above
        // Boolean
        asm.emitConstantPoolUTF8("java/lang/Boolean");
        asm.emitConstantPoolClass(asm.cpi());
        booleanIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(Z)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        booleanCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("booleanValue");
        asm.emitConstantPoolUTF8("()Z");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        booleanUnboxIdx = asm.cpi();

        // Byte
        asm.emitConstantPoolUTF8("java/lang/Byte");
        asm.emitConstantPoolClass(asm.cpi());
        byteIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(B)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        byteCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("byteValue");
        asm.emitConstantPoolUTF8("()B");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        byteUnboxIdx = asm.cpi();

        // Character
        asm.emitConstantPoolUTF8("java/lang/Character");
        asm.emitConstantPoolClass(asm.cpi());
        characterIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(C)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        characterCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("charValue");
        asm.emitConstantPoolUTF8("()C");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        characterUnboxIdx = asm.cpi();

        // Double
        asm.emitConstantPoolUTF8("java/lang/Double");
        asm.emitConstantPoolClass(asm.cpi());
        doubleIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(D)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        doubleCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("doubleValue");
        asm.emitConstantPoolUTF8("()D");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        doubleUnboxIdx = asm.cpi();

        // Float
        asm.emitConstantPoolUTF8("java/lang/Float");
        asm.emitConstantPoolClass(asm.cpi());
        floatIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(F)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        floatCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("floatValue");
        asm.emitConstantPoolUTF8("()F");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        floatUnboxIdx = asm.cpi();

        // Integer
        asm.emitConstantPoolUTF8("java/lang/Integer");
        asm.emitConstantPoolClass(asm.cpi());
        integerIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(I)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        integerCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("intValue");
        asm.emitConstantPoolUTF8("()I");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        integerUnboxIdx = asm.cpi();

        // Long
        asm.emitConstantPoolUTF8("java/lang/Long");
        asm.emitConstantPoolClass(asm.cpi());
        longIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(J)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        longCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("longValue");
        asm.emitConstantPoolUTF8("()J");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        longUnboxIdx = asm.cpi();

        // Short
        asm.emitConstantPoolUTF8("java/lang/Short");
        asm.emitConstantPoolClass(asm.cpi());
        shortIdx = asm.cpi();
        asm.emitConstantPoolUTF8("(S)V");
        asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
        shortCtorIdx = asm.cpi();
        asm.emitConstantPoolUTF8("shortValue");
        asm.emitConstantPoolUTF8("()S");
        asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
        asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi());
        shortUnboxIdx = asm.cpi();
    }

    // Necessary because of Java's annoying promotion rules
    protected static short add(short s1, short s2) {
        return (short) (s1 + s2);
    }

    protected static short sub(short s1, short s2) {
        return (short) (s1 - s2);
    }

    protected boolean isStatic() {
        return Modifier.isStatic(modifiers);
    }

    protected boolean isPrivate() {
        return Modifier.isPrivate(modifiers);
    }

    /** Returns class name in "internal" form (i.e., '/' separators
        instead of '.') */
    protected static String getClassName
        (Class<?> c, boolean addPrefixAndSuffixForNonPrimitiveTypes)
    {
        if (c.isPrimitive()) {
            if (c == Boolean.TYPE) {
                return "Z";
            } else if (c == Byte.TYPE) {
                return "B";
            } else if (c == Character.TYPE) {
                return "C";
            } else if (c == Double.TYPE) {
                return "D";
            } else if (c == Float.TYPE) {
                return "F";
            } else if (c == Integer.TYPE) {
                return "I";
            } else if (c == Long.TYPE) {
                return "J";
            } else if (c == Short.TYPE) {
                return "S";
            } else if (c == Void.TYPE) {
                return "V";
            }
            throw new InternalError("Should have found primitive type");
        } else if (c.isArray()) {
            return "[" + getClassName(c.getComponentType(), true);
        } else {
            if (addPrefixAndSuffixForNonPrimitiveTypes) {
                return internalize("L" + c.getName() + ";");
            } else {
                return internalize(c.getName());
            }
        }
    }

    private static String internalize(String className) {
        return className.replace('.', '/');
    }

    protected void emitConstructor() {
        // Generate code into fresh code buffer
        ClassFileAssembler cb = new ClassFileAssembler();
        // 0 incoming arguments
        cb.setMaxLocals(1);
        cb.opc_aload_0();
        cb.opc_invokespecial(superCtorIdx, 0, 0);
        cb.opc_return();

        // Emit method
        emitMethod(initIdx, cb.getMaxLocals(), cb, null, null);
    }

    // The descriptor's index in the constant pool must be (1 +
    // nameIdx). "numArgs" must indicate ALL arguments, including the
    // implicit "this" argument; double and long arguments each count
    // as 2 in this count. The code buffer must NOT contain the code
    // length. The exception table may be null, but if non-null must
    // NOT contain the exception table's length. The checked exception
    // indices may be null.
    protected void emitMethod(short nameIdx,
                              int numArgs,
                              ClassFileAssembler code,
                              ClassFileAssembler exceptionTable,
                              short[] checkedExceptionIndices)
    {
        int codeLen = code.getLength();
        int excLen  = 0;
        if (exceptionTable != null) {
            excLen = exceptionTable.getLength();
            if ((excLen % 8) != 0) {
                throw new IllegalArgumentException("Illegal exception table");
            }
        }
        int attrLen = 12 + codeLen + excLen;
        excLen = excLen / 8; // No-op if no exception table

        asm.emitShort(ACC_PUBLIC);
        asm.emitShort(nameIdx);
        asm.emitShort(add(nameIdx, S1));
        if (checkedExceptionIndices == null) {
            // Code attribute only
            asm.emitShort(S1);
        } else {
            // Code and Exceptions attributes
            asm.emitShort(S2);
        }
        // Code attribute
        asm.emitShort(codeIdx);
        asm.emitInt(attrLen);
        asm.emitShort(code.getMaxStack());
        asm.emitShort((short) Math.max(numArgs, code.getMaxLocals()));
        asm.emitInt(codeLen);
        asm.append(code);
        asm.emitShort((short) excLen);
        if (exceptionTable != null) {
            asm.append(exceptionTable);
        }
        asm.emitShort(S0); // No additional attributes for Code attribute
        if (checkedExceptionIndices != null) {
            // Exceptions attribute
            asm.emitShort(exceptionsIdx);
            asm.emitInt(2 + 2 * checkedExceptionIndices.length);
            asm.emitShort((short) checkedExceptionIndices.length);
            for (int i = 0; i < checkedExceptionIndices.length; i++) {
                asm.emitShort(checkedExceptionIndices[i]);
            }
        }
    }

    protected short indexForPrimitiveType(Class<?> type) {
        if (type == Boolean.TYPE) {
            return booleanIdx;
        } else if (type == Byte.TYPE) {
            return byteIdx;
        } else if (type == Character.TYPE) {
            return characterIdx;
        } else if (type == Double.TYPE) {
            return doubleIdx;
        } else if (type == Float.TYPE) {
            return floatIdx;
        } else if (type == Integer.TYPE) {
            return integerIdx;
        } else if (type == Long.TYPE) {
            return longIdx;
        } else if (type == Short.TYPE) {
            return shortIdx;
        }
        throw new InternalError("Should have found primitive type");
    }

    protected short ctorIndexForPrimitiveType(Class<?> type) {
        if (type == Boolean.TYPE) {
            return booleanCtorIdx;
        } else if (type == Byte.TYPE) {
            return byteCtorIdx;
        } else if (type == Character.TYPE) {
            return characterCtorIdx;
        } else if (type == Double.TYPE) {
            return doubleCtorIdx;
        } else if (type == Float.TYPE) {
            return floatCtorIdx;
        } else if (type == Integer.TYPE) {
            return integerCtorIdx;
        } else if (type == Long.TYPE) {
            return longCtorIdx;
        } else if (type == Short.TYPE) {
            return shortCtorIdx;
        }
        throw new InternalError("Should have found primitive type");
    }

    /** Returns true for widening or identity conversions for primitive
        types only */
    protected static boolean canWidenTo(Class<?> type, Class<?> otherType) {
        if (!type.isPrimitive()) {
            return false;
        }

        // Widening conversions (from JVM spec):
        //  byte to short, int, long, float, or double
        //  short to int, long, float, or double
        //  char to int, long, float, or double
        //  int to long, float, or double
        //  long to float or double
        //  float to double

        if (type == Boolean.TYPE) {
            if (otherType == Boolean.TYPE) {
                return true;
            }
        } else if (type == Byte.TYPE) {
            if (   otherType == Byte.TYPE
                   || otherType == Short.TYPE
                   || otherType == Integer.TYPE
                   || otherType == Long.TYPE
                   || otherType == Float.TYPE
                   || otherType == Double.TYPE) {
                return true;
            }
        } else if (type == Short.TYPE) {
            if (   otherType == Short.TYPE
                   || otherType == Integer.TYPE
                   || otherType == Long.TYPE
                   || otherType == Float.TYPE
                   || otherType == Double.TYPE) {
                return true;
            }
        } else if (type == Character.TYPE) {
            if (   otherType == Character.TYPE
                   || otherType == Integer.TYPE
                   || otherType == Long.TYPE
                   || otherType == Float.TYPE
                   || otherType == Double.TYPE) {
                return true;
            }
        } else if (type == Integer.TYPE) {
            if (   otherType == Integer.TYPE
                   || otherType == Long.TYPE
                   || otherType == Float.TYPE
                   || otherType == Double.TYPE) {
                return true;
            }
        } else if (type == Long.TYPE) {
            if (   otherType == Long.TYPE
                   || otherType == Float.TYPE
                   || otherType == Double.TYPE) {
                return true;
            }
        } else if (type == Float.TYPE) {
            if (   otherType == Float.TYPE
                   || otherType == Double.TYPE) {
                return true;
            }
        } else if (type == Double.TYPE) {
            if (otherType == Double.TYPE) {
                return true;
            }
        }

        return false;
    }

    /** Emits the widening bytecode for the given primitive conversion
        (or none if the identity conversion). Requires that a primitive
        conversion exists; i.e., canWidenTo must have already been
        called and returned true. */
    protected static void emitWideningBytecodeForPrimitiveConversion
        (ClassFileAssembler cb,
         Class<?> fromType,
         Class<?> toType)
    {
        // Note that widening conversions for integral types (i.e., "b2s",
        // "s2i") are no-ops since values on the Java stack are
        // sign-extended.

        // Widening conversions (from JVM spec):
        //  byte to short, int, long, float, or double
        //  short to int, long, float, or double
        //  char to int, long, float, or double
        //  int to long, float, or double
        //  long to float or double
        //  float to double

        if (   fromType == Byte.TYPE
               || fromType == Short.TYPE
               || fromType == Character.TYPE
               || fromType == Integer.TYPE) {
            if (toType == Long.TYPE) {
                cb.opc_i2l();
            } else if (toType == Float.TYPE) {
                cb.opc_i2f();
            } else if (toType == Double.TYPE) {
                cb.opc_i2d();
            }
        } else if (fromType == Long.TYPE) {
            if (toType == Float.TYPE) {
                cb.opc_l2f();
            } else if (toType == Double.TYPE) {
                cb.opc_l2d();
            }
        } else if (fromType == Float.TYPE) {
            if (toType == Double.TYPE) {
                cb.opc_f2d();
            }
        }

        // Otherwise, was identity or no-op conversion. Fall through.
    }

    protected short unboxingMethodForPrimitiveType(Class<?> primType) {
        if (primType == Boolean.TYPE) {
            return booleanUnboxIdx;
        } else if (primType == Byte.TYPE) {
            return byteUnboxIdx;
        } else if (primType == Character.TYPE) {
            return characterUnboxIdx;
        } else if (primType == Short.TYPE) {
            return shortUnboxIdx;
        } else if (primType == Integer.TYPE) {
            return integerUnboxIdx;
        } else if (primType == Long.TYPE) {
            return longUnboxIdx;
        } else if (primType == Float.TYPE) {
            return floatUnboxIdx;
        } else if (primType == Double.TYPE) {
            return doubleUnboxIdx;
        }
        throw new InternalError("Illegal primitive type " + primType.getName());
    }

    protected static final Class<?>[] primitiveTypes = new Class<?>[] {
        Boolean.TYPE,
        Byte.TYPE,
        Character.TYPE,
        Short.TYPE,
        Integer.TYPE,
        Long.TYPE,
        Float.TYPE,
        Double.TYPE
    };

    /** We don't consider "Void" to be a primitive type */
    protected static boolean isPrimitive(Class<?> c) {
        return (c.isPrimitive() && c != Void.TYPE);
    }

    protected int typeSizeInStackSlots(Class<?> c) {
        if (c == Void.TYPE) {
            return 0;
        }
        if (c == Long.TYPE || c == Double.TYPE) {
            return 2;
        }
        return 1;
    }

    private ClassFileAssembler illegalArgumentCodeBuffer;
    protected ClassFileAssembler illegalArgumentCodeBuffer() {
        if (illegalArgumentCodeBuffer == null) {
            illegalArgumentCodeBuffer = new ClassFileAssembler();
            illegalArgumentCodeBuffer.opc_new(illegalArgumentClass);
            illegalArgumentCodeBuffer.opc_dup();
            illegalArgumentCodeBuffer.opc_invokespecial(illegalArgumentCtorIdx, 0, 0);
            illegalArgumentCodeBuffer.opc_athrow();
        }

        return illegalArgumentCodeBuffer;
    }
}
