jdk.internal.org.objectweb.asm.tree.TypeInsnNode Java Examples

The following examples show how to use jdk.internal.org.objectweb.asm.tree.TypeInsnNode. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.

Example #1

Source File: BasicInterpreter.java From dragonwell8_jdk with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #2

Source File: BasicInterpreter.java From TencentKona-8 with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #3

Source File: BasicInterpreter.java From jdk8u60 with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #4

Source File: BasicInterpreter.java From openjdk-jdk8u with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #5

Source File: BasicInterpreter.java From openjdk-jdk8u-backup with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #6

Source File: BasicInterpreter.java From Bytecoder with Apache License 2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn) throws AnalyzerException {
    switch (insn.getOpcode()) {
        case ACONST_NULL:
            return newValue(NULL_TYPE);
        case ICONST_M1:
        case ICONST_0:
        case ICONST_1:
        case ICONST_2:
        case ICONST_3:
        case ICONST_4:
        case ICONST_5:
            return BasicValue.INT_VALUE;
        case LCONST_0:
        case LCONST_1:
            return BasicValue.LONG_VALUE;
        case FCONST_0:
        case FCONST_1:
        case FCONST_2:
            return BasicValue.FLOAT_VALUE;
        case DCONST_0:
        case DCONST_1:
            return BasicValue.DOUBLE_VALUE;
        case BIPUSH:
        case SIPUSH:
            return BasicValue.INT_VALUE;
        case LDC:
            Object value = ((LdcInsnNode) insn).cst;
            if (value instanceof Integer) {
                return BasicValue.INT_VALUE;
            } else if (value instanceof Float) {
                return BasicValue.FLOAT_VALUE;
            } else if (value instanceof Long) {
                return BasicValue.LONG_VALUE;
            } else if (value instanceof Double) {
                return BasicValue.DOUBLE_VALUE;
            } else if (value instanceof String) {
                return newValue(Type.getObjectType("java/lang/String"));
            } else if (value instanceof Type) {
                int sort = ((Type) value).getSort();
                if (sort == Type.OBJECT || sort == Type.ARRAY) {
                    return newValue(Type.getObjectType("java/lang/Class"));
                } else if (sort == Type.METHOD) {
                    return newValue(Type.getObjectType("java/lang/invoke/MethodType"));
                } else {
                    throw new AnalyzerException(insn, "Illegal LDC value " + value);
                }
            } else if (value instanceof Handle) {
                return newValue(Type.getObjectType("java/lang/invoke/MethodHandle"));
            } else if (value instanceof ConstantDynamic) {
                return newValue(Type.getType(((ConstantDynamic) value).getDescriptor()));
            } else {
                throw new AnalyzerException(insn, "Illegal LDC value " + value);
            }
        case JSR:
            return BasicValue.RETURNADDRESS_VALUE;
        case GETSTATIC:
            return newValue(Type.getType(((FieldInsnNode) insn).desc));
        case NEW:
            return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
        default:
            throw new AssertionError();
    }
}

Example #7

Source File: BasicInterpreter.java From Bytecoder with Apache License 2.0

4 votes

@Override
public BasicValue unaryOperation(final AbstractInsnNode insn, final BasicValue value)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
        case INEG:
        case IINC:
        case L2I:
        case F2I:
        case D2I:
        case I2B:
        case I2C:
        case I2S:
            return BasicValue.INT_VALUE;
        case FNEG:
        case I2F:
        case L2F:
        case D2F:
            return BasicValue.FLOAT_VALUE;
        case LNEG:
        case I2L:
        case F2L:
        case D2L:
            return BasicValue.LONG_VALUE;
        case DNEG:
        case I2D:
        case L2D:
        case F2D:
            return BasicValue.DOUBLE_VALUE;
        case IFEQ:
        case IFNE:
        case IFLT:
        case IFGE:
        case IFGT:
        case IFLE:
        case TABLESWITCH:
        case LOOKUPSWITCH:
        case IRETURN:
        case LRETURN:
        case FRETURN:
        case DRETURN:
        case ARETURN:
        case PUTSTATIC:
            return null;
        case GETFIELD:
            return newValue(Type.getType(((FieldInsnNode) insn).desc));
        case NEWARRAY:
            switch (((IntInsnNode) insn).operand) {
                case T_BOOLEAN:
                    return newValue(Type.getType("[Z"));
                case T_CHAR:
                    return newValue(Type.getType("[C"));
                case T_BYTE:
                    return newValue(Type.getType("[B"));
                case T_SHORT:
                    return newValue(Type.getType("[S"));
                case T_INT:
                    return newValue(Type.getType("[I"));
                case T_FLOAT:
                    return newValue(Type.getType("[F"));
                case T_DOUBLE:
                    return newValue(Type.getType("[D"));
                case T_LONG:
                    return newValue(Type.getType("[J"));
                default:
                    break;
            }
            throw new AnalyzerException(insn, "Invalid array type");
        case ANEWARRAY:
            return newValue(Type.getType("[" + Type.getObjectType(((TypeInsnNode) insn).desc)));
        case ARRAYLENGTH:
            return BasicValue.INT_VALUE;
        case ATHROW:
            return null;
        case CHECKCAST:
            return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
        case INSTANCEOF:
            return BasicValue.INT_VALUE;
        case MONITORENTER:
        case MONITOREXIT:
        case IFNULL:
        case IFNONNULL:
            return null;
        default:
            throw new AssertionError();
    }
}

Example #8

Source File: BasicInterpreter.java From openjdk-jdk9 with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #9

Source File: BasicInterpreter.java From jdk8u-jdk with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #10

Source File: BasicInterpreter.java From hottub with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #11

Source File: BasicInterpreter.java From openjdk-8-source with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #12

Source File: BasicInterpreter.java From openjdk-8 with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #13

Source File: BasicInterpreter.java From jdk8u_jdk with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #14

Source File: BasicInterpreter.java From jdk8u-jdk with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #15

Source File: BasicInterpreter.java From jdk8u-dev-jdk with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException {
    switch (insn.getOpcode()) {
    case ACONST_NULL:
        return newValue(Type.getObjectType("null"));
    case ICONST_M1:
    case ICONST_0:
    case ICONST_1:
    case ICONST_2:
    case ICONST_3:
    case ICONST_4:
    case ICONST_5:
        return BasicValue.INT_VALUE;
    case LCONST_0:
    case LCONST_1:
        return BasicValue.LONG_VALUE;
    case FCONST_0:
    case FCONST_1:
    case FCONST_2:
        return BasicValue.FLOAT_VALUE;
    case DCONST_0:
    case DCONST_1:
        return BasicValue.DOUBLE_VALUE;
    case BIPUSH:
    case SIPUSH:
        return BasicValue.INT_VALUE;
    case LDC:
        Object cst = ((LdcInsnNode) insn).cst;
        if (cst instanceof Integer) {
            return BasicValue.INT_VALUE;
        } else if (cst instanceof Float) {
            return BasicValue.FLOAT_VALUE;
        } else if (cst instanceof Long) {
            return BasicValue.LONG_VALUE;
        } else if (cst instanceof Double) {
            return BasicValue.DOUBLE_VALUE;
        } else if (cst instanceof String) {
            return newValue(Type.getObjectType("java/lang/String"));
        } else if (cst instanceof Type) {
            int sort = ((Type) cst).getSort();
            if (sort == Type.OBJECT || sort == Type.ARRAY) {
                return newValue(Type.getObjectType("java/lang/Class"));
            } else if (sort == Type.METHOD) {
                return newValue(Type
                        .getObjectType("java/lang/invoke/MethodType"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant "
                        + cst);
            }
        } else if (cst instanceof Handle) {
            return newValue(Type
                    .getObjectType("java/lang/invoke/MethodHandle"));
        } else {
            throw new IllegalArgumentException("Illegal LDC constant "
                    + cst);
        }
    case JSR:
        return BasicValue.RETURNADDRESS_VALUE;
    case GETSTATIC:
        return newValue(Type.getType(((FieldInsnNode) insn).desc));
    case NEW:
        return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
    default:
        throw new Error("Internal error.");
    }
}

Example #16

Source File: BasicInterpreter.java From nashorn with GNU General Public License v2.0

4 votes

@Override
public BasicValue newOperation(final AbstractInsnNode insn)
        throws AnalyzerException
{
    switch (insn.getOpcode()) {
        case ACONST_NULL:
            return newValue(Type.getObjectType("null"));
        case ICONST_M1:
        case ICONST_0:
        case ICONST_1:
        case ICONST_2:
        case ICONST_3:
        case ICONST_4:
        case ICONST_5:
            return BasicValue.INT_VALUE;
        case LCONST_0:
        case LCONST_1:
            return BasicValue.LONG_VALUE;
        case FCONST_0:
        case FCONST_1:
        case FCONST_2:
            return BasicValue.FLOAT_VALUE;
        case DCONST_0:
        case DCONST_1:
            return BasicValue.DOUBLE_VALUE;
        case BIPUSH:
        case SIPUSH:
            return BasicValue.INT_VALUE;
        case LDC:
            Object cst = ((LdcInsnNode) insn).cst;
            if (cst instanceof Integer) {
                return BasicValue.INT_VALUE;
            } else if (cst instanceof Float) {
                return BasicValue.FLOAT_VALUE;
            } else if (cst instanceof Long) {
                return BasicValue.LONG_VALUE;
            } else if (cst instanceof Double) {
                return BasicValue.DOUBLE_VALUE;
            } else if (cst instanceof String) {
                return newValue(Type.getObjectType("java/lang/String"));
            } else if (cst instanceof Type) {
                int sort = ((Type) cst).getSort();
                if (sort == Type.OBJECT || sort == Type.ARRAY) {
                    return newValue(Type.getObjectType("java/lang/Class"));
                } else if (sort == Type.METHOD) {
                    return newValue(Type.getObjectType("java/lang/invoke/MethodType"));
                } else {
                    throw new IllegalArgumentException("Illegal LDC constant " + cst);
                }
            } else if (cst instanceof Handle) {
                return newValue(Type.getObjectType("java/lang/invoke/MethodHandle"));
            } else {
                throw new IllegalArgumentException("Illegal LDC constant " + cst);
            }
        case JSR:
            return BasicValue.RETURNADDRESS_VALUE;
        case GETSTATIC:
            return newValue(Type.getType(((FieldInsnNode) insn).desc));
        case NEW:
            return newValue(Type.getObjectType(((TypeInsnNode) insn).desc));
        default:
            throw new Error("Internal error.");
    }
}