Examples with Type org.objectweb.asm.Type used on opensource projects

Example 11 with Type

use of org.objectweb.asm.Type in project dex2jar by pxb1988.

the class JasminDumper method dump.

public void dump(ClassNode cn) {
    labelNames.clear();
    pw.print(".bytecode ");
    pw.print(cn.version & 0xFFFF);
    pw.print('.');
    pw.println(cn.version >>> 16);
    println(".source ", cn.sourceFile);
    pw.print(".class");
    pw.print(access_clz(cn.access));
    pw.print(' ');
    printIdAfterAccess(pw, cn.name);
    pw.println();
    if (cn.superName != null) {
        pw.print(".super ");
        printIdAfterAccess(pw, cn.superName);
        pw.println();
    }
    for (String itf : cn.interfaces) {
        pw.print(".implements ");
        printIdAfterAccess(pw, itf);
        pw.println();
    }
    if (cn.signature != null) {
        println(".signature ", '"' + cn.signature + '"');
    }
    if (cn.outerClass != null) {
        pw.print(".enclosing method ");
        pw.print(cn.outerClass);
        if (cn.outerMethod != null) {
            pw.print('/');
            pw.print(cn.outerMethod);
            pw.println(cn.outerMethodDesc);
        } else {
            pw.println();
        }
    }
    if ((cn.access & Opcodes.ACC_DEPRECATED) != 0) {
        pw.println(".deprecated");
    }
    if (cn.visibleAnnotations != null) {
        for (AnnotationNode an : cn.visibleAnnotations) {
            printAnnotation(an, 1, -1);
        }
    }
    if (cn.invisibleAnnotations != null) {
        for (AnnotationNode an : cn.invisibleAnnotations) {
            printAnnotation(an, 2, -1);
        }
    }
    println(".debug ", cn.sourceDebug == null ? null : '"' + cn.sourceDebug + '"');
    for (InnerClassNode in : cn.innerClasses) {
        pw.print(".inner class");
        pw.print(access_clz(in.access & (~Opcodes.ACC_SUPER)));
        if (in.innerName != null) {
            pw.print(' ');
            printIdAfterAccess(pw, in.innerName);
        }
        if (in.name != null) {
            pw.print(" inner ");
            pw.print(in.name);
        }
        if (in.outerName != null) {
            pw.print(" outer ");
            pw.print(in.outerName);
        }
        pw.println();
    }
    for (FieldNode fn : cn.fields) {
        boolean annotations = false;
        if (fn.visibleAnnotations != null && fn.visibleAnnotations.size() > 0) {
            annotations = true;
        }
        if (fn.invisibleAnnotations != null && fn.invisibleAnnotations.size() > 0) {
            annotations = true;
        }
        boolean deprecated = (fn.access & Opcodes.ACC_DEPRECATED) != 0;
        pw.print("\n.field");
        pw.print(access_fld(fn.access));
        pw.print(' ');
        printIdAfterAccess(pw, fn.name);
        pw.print(' ');
        pw.print(fn.desc);
        if (fn.value instanceof String) {
            StringBuffer buf = new StringBuffer();
            Printer.appendString(buf, (String) fn.value);
            pw.print(" = ");
            pw.print(buf.toString());
        } else if (fn.value != null) {
            pw.print(" = ");
            print(fn.value);
        }
        pw.println();
        if (fn.signature != null) {
            pw.print(".signature \"");
            pw.print(fn.signature);
            pw.println("\"");
        }
        if (deprecated) {
            pw.println(".deprecated");
        }
        if (fn.visibleAnnotations != null) {
            for (AnnotationNode an : fn.visibleAnnotations) {
                printAnnotation(an, 1, -1);
            }
        }
        if (fn.invisibleAnnotations != null) {
            for (AnnotationNode an : fn.invisibleAnnotations) {
                printAnnotation(an, 2, -1);
            }
        }
        if (fn.signature != null || deprecated || annotations) {
            pw.println(".end field");
        }
    }
    for (MethodNode mn : cn.methods) {
        pw.print("\n.method");
        pw.print(access_mtd(mn.access));
        pw.print(' ');
        printIdAfterAccess(pw, mn.name);
        pw.println(mn.desc);
        if (mn.signature != null) {
            pw.print(".signature \"");
            pw.print(mn.signature);
            pw.println("\"");
        }
        if (mn.annotationDefault != null) {
            pw.println(".annotation default");
            printAnnotationValue(mn.annotationDefault);
            pw.println(".end annotation");
        }
        if (mn.visibleAnnotations != null) {
            for (AnnotationNode an : mn.visibleAnnotations) {
                printAnnotation(an, 1, -1);
            }
        }
        if (mn.invisibleAnnotations != null) {
            for (AnnotationNode an : mn.invisibleAnnotations) {
                printAnnotation(an, 2, -1);
            }
        }
        if (mn.visibleParameterAnnotations != null) {
            for (int j = 0; j < mn.visibleParameterAnnotations.length; ++j) {
                List<AnnotationNode> pas = mn.visibleParameterAnnotations[j];
                if (pas != null) {
                    for (AnnotationNode an : pas) {
                        printAnnotation(an, 1, j + 1);
                    }
                }
            }
        }
        if (mn.invisibleParameterAnnotations != null) {
            for (int j = 0; j < mn.invisibleParameterAnnotations.length; ++j) {
                List<AnnotationNode> pas = mn.invisibleParameterAnnotations[j];
                if (pas != null) {
                    for (AnnotationNode an : pas) {
                        printAnnotation(an, 2, j + 1);
                    }
                }
            }
        }
        for (String ex : mn.exceptions) {
            println(".throws ", ex);
        }
        if ((mn.access & Opcodes.ACC_DEPRECATED) != 0) {
            pw.println(".deprecated");
        }
        if (mn.instructions != null && mn.instructions.size() > 0) {
            labelNames.clear();
            if (mn.tryCatchBlocks != null) {
                for (TryCatchBlockNode tcb : mn.tryCatchBlocks) {
                    pw.print(".catch ");
                    pw.print(tcb.type == null ? "all" : "all".equals(tcb.type) ? "\\u0097ll" : tcb.type);
                    pw.print(" from ");
                    print(tcb.start);
                    pw.print(" to ");
                    print(tcb.end);
                    pw.print(" using ");
                    print(tcb.handler);
                    pw.println();
                }
            }
            for (int j = 0; j < mn.instructions.size(); ++j) {
                AbstractInsnNode in = mn.instructions.get(j);
                if (in.getType() != AbstractInsnNode.LINE && in.getType() != AbstractInsnNode.FRAME) {
                    if (in.getType() == AbstractInsnNode.LABEL) {
                        pw.print("  ");
                    } else {
                        pw.print("    ");
                    }
                }
                in.accept(new MethodVisitor(ASM4) {

                    @Override
                    public void visitInsn(int opcode) {
                        print(opcode);
                        pw.println();
                    }

                    @Override
                    public void visitIntInsn(int opcode, int operand) {
                        print(opcode);
                        if (opcode == Opcodes.NEWARRAY) {
                            switch(operand) {
                                case Opcodes.T_BOOLEAN:
                                    pw.println(" boolean");
                                    break;
                                case Opcodes.T_CHAR:
                                    pw.println(" char");
                                    break;
                                case Opcodes.T_FLOAT:
                                    pw.println(" float");
                                    break;
                                case Opcodes.T_DOUBLE:
                                    pw.println(" double");
                                    break;
                                case Opcodes.T_BYTE:
                                    pw.println(" byte");
                                    break;
                                case Opcodes.T_SHORT:
                                    pw.println(" short");
                                    break;
                                case Opcodes.T_INT:
                                    pw.println(" int");
                                    break;
                                case Opcodes.T_LONG:
                                default:
                                    pw.println(" long");
                                    break;
                            }
                        } else {
                            pw.print(' ');
                            pw.println(operand);
                        }
                    }

                    @Override
                    public void visitVarInsn(int opcode, int var) {
                        print(opcode);
                        pw.print(' ');
                        pw.println(var);
                    }

                    @Override
                    public void visitTypeInsn(int opcode, String type) {
                        print(opcode);
                        pw.print(' ');
                        pw.println(type);
                    }

                    @Override
                    public void visitFieldInsn(int opcode, String owner, String name, String desc) {
                        print(opcode);
                        pw.print(' ');
                        pw.print(owner);
                        pw.print('/');
                        pw.print(name);
                        pw.print(' ');
                        pw.println(desc);
                    }

                    @Override
                    public void visitMethodInsn(int opcode, String owner, String name, String desc) {
                        print(opcode);
                        pw.print(' ');
                        pw.print(owner);
                        pw.print('/');
                        pw.print(name);
                        pw.print(desc);
                        if (opcode == Opcodes.INVOKEINTERFACE) {
                            pw.print(' ');
                            pw.print((Type.getArgumentsAndReturnSizes(desc) >> 2) - 1);
                        }
                        pw.println();
                    }

                    @Override
                    public void visitJumpInsn(int opcode, Label label) {
                        print(opcode);
                        pw.print(' ');
                        print(label);
                        pw.println();
                    }

                    @Override
                    public void visitLabel(Label label) {
                        print(label);
                        pw.println(':');
                    }

                    @Override
                    public void visitLdcInsn(Object cst) {
                        if (cst instanceof Integer || cst instanceof Float) {
                            pw.print("ldc_w ");
                            print(cst);
                        } else if (cst instanceof Long || cst instanceof Double) {
                            pw.print("ldc2_w ");
                            print(cst);
                        } else {
                            pw.print("ldc ");
                            if (cst instanceof Type) {
                                pw.print(((Type) cst).getInternalName());
                            } else {
                                print(cst);
                            }
                        }
                        pw.println();
                    }

                    @Override
                    public void visitIincInsn(int var, int increment) {
                        pw.print("iinc ");
                        pw.print(var);
                        pw.print(' ');
                        pw.println(increment);
                    }

                    @Override
                    public void visitTableSwitchInsn(int min, int max, Label dflt, Label... labels) {
                        pw.print("tableswitch ");
                        pw.println(min);
                        for (Label label : labels) {
                            pw.print("      ");
                            print(label);
                            pw.println();
                        }
                        pw.print("      default : ");
                        print(dflt);
                        pw.println();
                    }

                    @Override
                    public void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels) {
                        pw.println("lookupswitch");
                        for (int i = 0; i < keys.length; ++i) {
                            pw.print("      ");
                            pw.print(keys[i]);
                            pw.print(" : ");
                            print(labels[i]);
                            pw.println();
                        }
                        pw.print("      default : ");
                        print(dflt);
                        pw.println();
                    }

                    @Override
                    public void visitMultiANewArrayInsn(String desc, int dims) {
                        pw.print("multianewarray ");
                        pw.print(desc);
                        pw.print(' ');
                        pw.println(dims);
                    }

                    @Override
                    public void visitLineNumber(int line, Label start) {
                        pw.print(".line ");
                        pw.println(line);
                    }
                });
            }
            if (mn.localVariables != null) {
                for (LocalVariableNode lv : mn.localVariables) {
                    pw.print("  .var ");
                    pw.print(lv.index);
                    pw.print(" is '");
                    pw.print(lv.name);
                    pw.print("' ");
                    pw.print(lv.desc);
                    if (lv.signature != null) {
                        pw.print(" signature \"");
                        pw.print(lv.signature);
                        pw.print("\"");
                    }
                    pw.print(" from ");
                    print(lv.start);
                    pw.print(" to ");
                    print(lv.end);
                    pw.println();
                }
            }
            println("  .limit locals ", Integer.toString(mn.maxLocals));
            println("  .limit stack ", Integer.toString(mn.maxStack));
        }
        pw.println(".end method");
    }
}

Example 12 with Type

use of org.objectweb.asm.Type in project dex2jar by pxb1988.

the class J2IRConverter method buildInterpreter.

private Interpreter<JvmValue> buildInterpreter() {
    return new Interpreter<JvmValue>(Opcodes.ASM4) {

        @Override
        public JvmValue newValue(Type type) {
            return null;
        }

        @Override
        public JvmValue newOperation(AbstractInsnNode insn) throws AnalyzerException {
            switch(insn.getOpcode()) {
                case ACONST_NULL:
                    return b(1, Exprs.nNull());
                case ICONST_M1:
                case ICONST_0:
                case ICONST_1:
                case ICONST_2:
                case ICONST_3:
                case ICONST_4:
                case ICONST_5:
                    return b(1, Exprs.nInt(insn.getOpcode() - ICONST_0));
                case LCONST_0:
                case LCONST_1:
                    return b(2, Exprs.nLong(insn.getOpcode() - LCONST_0));
                case FCONST_0:
                case FCONST_1:
                case FCONST_2:
                    return b(1, Exprs.nFloat(insn.getOpcode() - FCONST_0));
                case DCONST_0:
                case DCONST_1:
                    return b(2, Exprs.nDouble(insn.getOpcode() - DCONST_0));
                case BIPUSH:
                case SIPUSH:
                    return b(1, Exprs.nInt(((IntInsnNode) insn).operand));
                case LDC:
                    Object cst = ((LdcInsnNode) insn).cst;
                    if (cst instanceof Integer) {
                        return b(1, Exprs.nInt((Integer) cst));
                    } else if (cst instanceof Float) {
                        return b(1, Exprs.nFloat((Float) cst));
                    } else if (cst instanceof Long) {
                        return b(2, Exprs.nLong((Long) cst));
                    } else if (cst instanceof Double) {
                        return b(2, Exprs.nDouble((Double) cst));
                    } else if (cst instanceof String) {
                        return b(1, Exprs.nString((String) cst));
                    } else if (cst instanceof Type) {
                        Type type = (Type) cst;
                        int sort = type.getSort();
                        if (sort == Type.OBJECT || sort == Type.ARRAY) {
                            return b(1, Exprs.nType(type.getDescriptor()));
                        } else if (sort == Type.METHOD) {
                            throw new UnsupportedOperationException("Not supported yet.");
                        } else {
                            throw new IllegalArgumentException("Illegal LDC constant " + cst);
                        }
                    } else if (cst instanceof Handle) {
                        throw new UnsupportedOperationException("Not supported yet.");
                    } else {
                        throw new IllegalArgumentException("Illegal LDC constant " + cst);
                    }
                case JSR:
                    throw new UnsupportedOperationException("Not supported yet.");
                case GETSTATIC:
                    FieldInsnNode fin = (FieldInsnNode) insn;
                    return b(Type.getType(fin.desc).getSize(), Exprs.nStaticField("L" + fin.owner + ";", fin.name, fin.desc));
                case NEW:
                    return b(1, Exprs.nNew("L" + ((TypeInsnNode) insn).desc + ";"));
                default:
                    throw new Error("Internal error.");
            }
        }

        @Override
        public JvmValue copyOperation(AbstractInsnNode insn, JvmValue value) throws AnalyzerException {
            return b(value.getSize(), getLocal(value));
        }

        @Override
        public JvmValue unaryOperation(AbstractInsnNode insn, JvmValue value0) throws AnalyzerException {
            Local local = value0 == null ? null : getLocal(value0);
            switch(insn.getOpcode()) {
                case INEG:
                    return b(1, Exprs.nNeg(local, "I"));
                case IINC:
                    return b(1, Exprs.nAdd(local, Exprs.nInt(((IincInsnNode) insn).incr), "I"));
                case L2I:
                    return b(1, Exprs.nCast(local, "J", "I"));
                case F2I:
                    return b(1, Exprs.nCast(local, "F", "I"));
                case D2I:
                    return b(1, Exprs.nCast(local, "D", "I"));
                case I2B:
                    return b(1, Exprs.nCast(local, "I", "B"));
                case I2C:
                    return b(1, Exprs.nCast(local, "I", "C"));
                case I2S:
                    return b(1, Exprs.nCast(local, "I", "S"));
                case FNEG:
                    return b(1, Exprs.nNeg(local, "F"));
                case I2F:
                    return b(1, Exprs.nCast(local, "I", "F"));
                case L2F:
                    return b(1, Exprs.nCast(local, "J", "F"));
                case D2F:
                    return b(1, Exprs.nCast(local, "D", "F"));
                case LNEG:
                    return b(2, Exprs.nNeg(local, "J"));
                case I2L:
                    return b(2, Exprs.nCast(local, "I", "J"));
                case F2L:
                    return b(2, Exprs.nCast(local, "F", "J"));
                case D2L:
                    return b(2, Exprs.nCast(local, "D", "J"));
                case DNEG:
                    return b(2, Exprs.nNeg(local, "D"));
                case I2D:
                    return b(2, Exprs.nCast(local, "I", "D"));
                case L2D:
                    return b(2, Exprs.nCast(local, "J", "D"));
                case F2D:
                    return b(2, Exprs.nCast(local, "F", "D"));
                case IFEQ:
                    emit(Stmts.nIf(Exprs.nEq(local, Exprs.nInt(0), "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IFNE:
                    emit(Stmts.nIf(Exprs.nNe(local, Exprs.nInt(0), "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IFLT:
                    emit(Stmts.nIf(Exprs.nLt(local, Exprs.nInt(0), "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IFGE:
                    emit(Stmts.nIf(Exprs.nGe(local, Exprs.nInt(0), "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IFGT:
                    emit(Stmts.nIf(Exprs.nGt(local, Exprs.nInt(0), "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IFLE:
                    emit(Stmts.nIf(Exprs.nLe(local, Exprs.nInt(0), "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case TABLESWITCH:
                    {
                        TableSwitchInsnNode ts = (TableSwitchInsnNode) insn;
                        LabelStmt[] targets = new LabelStmt[ts.labels.size()];
                        for (int i = 0; i < ts.labels.size(); i++) {
                            targets[i] = getLabel((LabelNode) ts.labels.get(i));
                        }
                        emit(Stmts.nTableSwitch(local, ts.min, targets, getLabel(ts.dflt)));
                        return null;
                    }
                case LOOKUPSWITCH:
                    {
                        LookupSwitchInsnNode ls = (LookupSwitchInsnNode) insn;
                        LabelStmt[] targets = new LabelStmt[ls.labels.size()];
                        int[] lookupValues = new int[ls.labels.size()];
                        for (int i = 0; i < ls.labels.size(); i++) {
                            targets[i] = getLabel((LabelNode) ls.labels.get(i));
                            lookupValues[i] = (Integer) ls.keys.get(i);
                        }
                        emit(Stmts.nLookupSwitch(local, lookupValues, targets, getLabel(ls.dflt)));
                        return null;
                    }
                case IRETURN:
                case LRETURN:
                case FRETURN:
                case DRETURN:
                case ARETURN:
                    // skip, move to returnOperation
                    return null;
                case PUTSTATIC:
                    {
                        FieldInsnNode fin = (FieldInsnNode) insn;
                        emit(Stmts.nAssign(Exprs.nStaticField("L" + fin.owner + ";", fin.name, fin.desc), local));
                        return null;
                    }
                case GETFIELD:
                    {
                        FieldInsnNode fin = (FieldInsnNode) insn;
                        Type fieldType = Type.getType(fin.desc);
                        return b(fieldType.getSize(), Exprs.nField(local, "L" + fin.owner + ";", fin.name, fin.desc));
                    }
                case NEWARRAY:
                    switch(((IntInsnNode) insn).operand) {
                        case T_BOOLEAN:
                            return b(1, Exprs.nNewArray("Z", local));
                        case T_CHAR:
                            return b(1, Exprs.nNewArray("C", local));
                        case T_BYTE:
                            return b(1, Exprs.nNewArray("B", local));
                        case T_SHORT:
                            return b(1, Exprs.nNewArray("S", local));
                        case T_INT:
                            return b(1, Exprs.nNewArray("I", local));
                        case T_FLOAT:
                            return b(1, Exprs.nNewArray("F", local));
                        case T_DOUBLE:
                            return b(1, Exprs.nNewArray("D", local));
                        case T_LONG:
                            return b(1, Exprs.nNewArray("D", local));
                        default:
                            throw new AnalyzerException(insn, "Invalid array type");
                    }
                case ANEWARRAY:
                    String desc = "L" + ((TypeInsnNode) insn).desc + ";";
                    return b(1, Exprs.nNewArray(desc, local));
                case ARRAYLENGTH:
                    return b(1, Exprs.nLength(local));
                case ATHROW:
                    emit(Stmts.nThrow(local));
                    return null;
                case CHECKCAST:
                    String orgDesc = ((TypeInsnNode) insn).desc;
                    desc = orgDesc.startsWith("[") ? orgDesc : ("L" + orgDesc + ";");
                    return b(1, Exprs.nCheckCast(local, desc));
                case INSTANCEOF:
                    return b(1, Exprs.nInstanceOf(local, "L" + ((TypeInsnNode) insn).desc + ";"));
                case MONITORENTER:
                    emit(Stmts.nLock(local));
                    return null;
                case MONITOREXIT:
                    emit(Stmts.nUnLock(local));
                    return null;
                case IFNULL:
                    emit(Stmts.nIf(Exprs.nEq(local, Exprs.nNull(), "L"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IFNONNULL:
                    emit(Stmts.nIf(Exprs.nNe(local, Exprs.nNull(), "L"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case // special case
                GOTO:
                    emit(Stmts.nGoto(getLabel(((JumpInsnNode) insn).label)));
                    return null;
                default:
                    throw new Error("Internal error.");
            }
        }

        JvmValue b(int size, com.googlecode.dex2jar.ir.expr.Value value) {
            Local local = newLocal();
            emit(Stmts.nAssign(local, value));
            return new JvmValue(size, local);
        }

        @Override
        public JvmValue binaryOperation(AbstractInsnNode insn, JvmValue value10, JvmValue value20) throws AnalyzerException {
            Local local1 = getLocal(value10);
            Local local2 = getLocal(value20);
            switch(insn.getOpcode()) {
                case IALOAD:
                    return b(1, Exprs.nArray(local1, local2, "I"));
                case BALOAD:
                    return b(1, Exprs.nArray(local1, local2, "B"));
                case CALOAD:
                    return b(1, Exprs.nArray(local1, local2, "C"));
                case SALOAD:
                    return b(1, Exprs.nArray(local1, local2, "S"));
                case FALOAD:
                    return b(1, Exprs.nArray(local1, local2, "F"));
                case AALOAD:
                    return b(1, Exprs.nArray(local1, local2, "L"));
                case DALOAD:
                    return b(1, Exprs.nArray(local1, local2, "D"));
                case LALOAD:
                    return b(1, Exprs.nArray(local1, local2, "J"));
                case IADD:
                    return b(1, Exprs.nAdd(local1, local2, "I"));
                case ISUB:
                    return b(1, Exprs.nSub(local1, local2, "I"));
                case IMUL:
                    return b(1, Exprs.nMul(local1, local2, "I"));
                case IDIV:
                    return b(1, Exprs.nDiv(local1, local2, "I"));
                case IREM:
                    return b(1, Exprs.nRem(local1, local2, "I"));
                case ISHL:
                    return b(1, Exprs.nShl(local1, local2, "I"));
                case ISHR:
                    return b(1, Exprs.nShr(local1, local2, "I"));
                case IUSHR:
                    return b(1, Exprs.nUshr(local1, local2, "I"));
                case IAND:
                    return b(1, Exprs.nAnd(local1, local2, "I"));
                case IOR:
                    return b(1, Exprs.nOr(local1, local2, "I"));
                case IXOR:
                    return b(1, Exprs.nXor(local1, local2, "I"));
                case FADD:
                    return b(1, Exprs.nAdd(local1, local2, "F"));
                case FSUB:
                    return b(1, Exprs.nSub(local1, local2, "F"));
                case FMUL:
                    return b(1, Exprs.nMul(local1, local2, "F"));
                case FDIV:
                    return b(1, Exprs.nDiv(local1, local2, "F"));
                case FREM:
                    return b(1, Exprs.nRem(local1, local2, "F"));
                case LADD:
                    return b(2, Exprs.nAdd(local1, local2, "J"));
                case LSUB:
                    return b(2, Exprs.nSub(local1, local2, "J"));
                case LMUL:
                    return b(2, Exprs.nMul(local1, local2, "J"));
                case LDIV:
                    return b(2, Exprs.nDiv(local1, local2, "J"));
                case LREM:
                    return b(2, Exprs.nRem(local1, local2, "J"));
                case LSHL:
                    return b(2, Exprs.nShl(local1, local2, "J"));
                case LSHR:
                    return b(2, Exprs.nShr(local1, local2, "J"));
                case LUSHR:
                    return b(2, Exprs.nUshr(local1, local2, "J"));
                case LAND:
                    return b(2, Exprs.nAnd(local1, local2, "J"));
                case LOR:
                    return b(2, Exprs.nOr(local1, local2, "J"));
                case LXOR:
                    return b(2, Exprs.nXor(local1, local2, "J"));
                case DADD:
                    return b(2, Exprs.nAdd(local1, local2, "D"));
                case DSUB:
                    return b(2, Exprs.nSub(local1, local2, "D"));
                case DMUL:
                    return b(2, Exprs.nMul(local1, local2, "D"));
                case DDIV:
                    return b(2, Exprs.nDiv(local1, local2, "D"));
                case DREM:
                    return b(2, Exprs.nRem(local1, local2, "D"));
                case LCMP:
                    return b(2, Exprs.nLCmp(local1, local2));
                case FCMPL:
                    return b(1, Exprs.nFCmpl(local1, local2));
                case FCMPG:
                    return b(1, Exprs.nFCmpg(local1, local2));
                case DCMPL:
                    return b(2, Exprs.nDCmpl(local1, local2));
                case DCMPG:
                    return b(2, Exprs.nDCmpg(local1, local2));
                case IF_ICMPEQ:
                    emit(Stmts.nIf(Exprs.nEq(local1, local2, "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IF_ICMPNE:
                    emit(Stmts.nIf(Exprs.nNe(local1, local2, "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IF_ICMPLT:
                    emit(Stmts.nIf(Exprs.nLt(local1, local2, "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IF_ICMPGE:
                    emit(Stmts.nIf(Exprs.nGe(local1, local2, "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IF_ICMPGT:
                    emit(Stmts.nIf(Exprs.nGt(local1, local2, "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IF_ICMPLE:
                    emit(Stmts.nIf(Exprs.nLe(local1, local2, "I"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IF_ACMPEQ:
                    emit(Stmts.nIf(Exprs.nEq(local1, local2, "L"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case IF_ACMPNE:
                    emit(Stmts.nIf(Exprs.nNe(local1, local2, "L"), getLabel(((JumpInsnNode) insn).label)));
                    return null;
                case PUTFIELD:
                    FieldInsnNode fin = (FieldInsnNode) insn;
                    emit(Stmts.nAssign(Exprs.nField(local1, "L" + fin.owner + ";", fin.name, fin.desc), local2));
                    return null;
                default:
                    throw new Error("Internal error.");
            }
        }

        @Override
        public JvmValue ternaryOperation(AbstractInsnNode insn, JvmValue value1, JvmValue value2, JvmValue value3) throws AnalyzerException {
            Local local1 = getLocal(value1);
            Local local2 = getLocal(value2);
            Local local3 = getLocal(value3);
            switch(insn.getOpcode()) {
                case IASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "I"), local3));
                    break;
                case LASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "J"), local3));
                    break;
                case FASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "F"), local3));
                    break;
                case DASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "D"), local3));
                    break;
                case AASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "L"), local3));
                    break;
                case BASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "B"), local3));
                    break;
                case CASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "C"), local3));
                    break;
                case SASTORE:
                    emit(Stmts.nAssign(Exprs.nArray(local1, local2, "S"), local3));
                    break;
            }
            return null;
        }

        public String[] toDescArray(Type[] ts) {
            String[] ds = new String[ts.length];
            for (int i = 0; i < ts.length; i++) {
                ds[i] = ts[i].getDescriptor();
            }
            return ds;
        }

        @Override
        public JvmValue naryOperation(AbstractInsnNode insn, List<? extends JvmValue> xvalues) throws AnalyzerException {
            com.googlecode.dex2jar.ir.expr.Value[] values = new com.googlecode.dex2jar.ir.expr.Value[xvalues.size()];
            for (int i = 0; i < xvalues.size(); i++) {
                values[i] = getLocal(xvalues.get(i));
            }
            if (insn.getOpcode() == MULTIANEWARRAY) {
                throw new UnsupportedOperationException("Not supported yet.");
            } else {
                MethodInsnNode mi = (MethodInsnNode) insn;
                com.googlecode.dex2jar.ir.expr.Value v = null;
                String ret = Type.getReturnType(mi.desc).getDescriptor();
                String owner = "L" + mi.owner + ";";
                String[] ps = toDescArray(Type.getArgumentTypes(mi.desc));
                switch(insn.getOpcode()) {
                    case INVOKEVIRTUAL:
                        v = Exprs.nInvokeVirtual(values, owner, mi.name, ps, ret);
                        break;
                    case INVOKESPECIAL:
                        v = Exprs.nInvokeSpecial(values, owner, mi.name, ps, ret);
                        break;
                    case INVOKESTATIC:
                        v = Exprs.nInvokeStatic(values, owner, mi.name, ps, ret);
                        break;
                    case INVOKEINTERFACE:
                        v = Exprs.nInvokeInterface(values, owner, mi.name, ps, ret);
                        break;
                    case INVOKEDYNAMIC:
                        throw new UnsupportedOperationException("Not supported yet.");
                }
                if ("V".equals(ret)) {
                    emit(Stmts.nVoidInvoke(v));
                    return null;
                } else {
                    return b(Type.getReturnType(mi.desc).getSize(), v);
                }
            }
        }

        @Override
        public JvmValue merge(JvmValue v, JvmValue w) {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        @Override
        public void returnOperation(AbstractInsnNode insn, JvmValue value, JvmValue expected) throws AnalyzerException {
            switch(insn.getOpcode()) {
                case IRETURN:
                case LRETURN:
                case FRETURN:
                case DRETURN:
                case ARETURN:
                    emit(Stmts.nReturn(getLocal(value)));
                    break;
                case RETURN:
                    emit(Stmts.nReturnVoid());
                    break;
            }
        }
    };
}

Example 13 with Type

use of org.objectweb.asm.Type in project dex2jar by pxb1988.

the class J2IRConverter method populate.

IrMethod populate(String owner, MethodNode source) {
    IrMethod target = new IrMethod();
    target.name = source.name;
    target.owner = "L" + owner + ";";
    target.ret = Type.getReturnType(source.desc).getDescriptor();
    Type[] args = Type.getArgumentTypes(source.desc);
    String[] sArgs = new String[args.length];
    target.args = sArgs;
    for (int i = 0; i < args.length; i++) {
        sArgs[i] = args[i].getDescriptor();
    }
    target.isStatic = 0 != (source.access & Opcodes.ACC_STATIC);
    return target;
}

Example 14 with Type

use of org.objectweb.asm.Type in project gradle by gradle.

the class ClassDependenciesVisitor method collectClassDependencies.

// performs a fast analysis of classes referenced in bytecode (method bodies)
// avoiding us to implement a costly visitor and potentially missing edge cases
private void collectClassDependencies(ClassReader reader) {
    char[] charBuffer = new char[reader.getMaxStringLength()];
    for (int i = 1; i < reader.getItemCount(); i++) {
        int itemOffset = reader.getItem(i);
        if (itemOffset > 0 && reader.readByte(itemOffset - 1) == 7) {
            // A CONSTANT_Class entry, read the class descriptor
            String classDescriptor = reader.readUTF8(itemOffset, charBuffer);
            Type type = Type.getObjectType(classDescriptor);
            while (type.getSort() == Type.ARRAY) {
                type = type.getElementType();
            }
            if (type.getSort() != Type.OBJECT) {
                // A primitive type
                continue;
            }
            String name = type.getClassName();
            maybeAddDependentType(name);
        }
    }
}

Example 15 with Type

use of org.objectweb.asm.Type in project groovy-core by groovy.

the class ProxyGeneratorAdapter method unwrapResult.

private void unwrapResult(final MethodVisitor mv, final String desc) {
    Type returnType = Type.getReturnType(desc);
    if (returnType == Type.VOID_TYPE) {
        mv.visitInsn(POP);
        mv.visitInsn(RETURN);
    } else {
        if (isPrimitive(returnType)) {
            BytecodeHelper.unbox(mv, ClassHelper.make(returnType.getClassName()));
        } else {
            mv.visitTypeInsn(CHECKCAST, returnType.getInternalName());
        }
        mv.visitInsn(getReturnInsn(returnType));
    }
}