Example usage for org.objectweb.asm.tree AbstractInsnNode getOpcode

List of usage examples for org.objectweb.asm.tree AbstractInsnNode getOpcode

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.tree.*
  5. AbstractInsnNode
  6. getOpcode

Introduction

In this page you can find the example usage for org.objectweb.asm.tree AbstractInsnNode getOpcode.

Prototype

public int getOpcode()

Source Link

Document

Returns the opcode of this instruction.

Usage

From source file:de.jiac.micro.config.analysis.BasicGuesser.java

License:Open Source License

public Value naryOperation(final AbstractInsnNode insn, final List values) throws AnalyzerException {
    if (insn.getOpcode() == MULTIANEWARRAY) {
        return newValue(Type.getType(((MultiANewArrayInsnNode) insn).desc));
    } else {/*from   w  w w .ja v  a  2  s.  c  om*/
        return newValue(Type.getReturnType(((MethodInsnNode) insn).desc));
    }
}

From source file:de.jiac.micro.config.analysis.MethodAnalyser.java

License:Open Source License

@Override
public void visitEnd() {
    final HashSet<String> obtainedHandles = new HashSet<String>();
    final ClassInfo ci = parent.classInfo;
    final MethodNode method = (MethodNode) mv;

    ci.referencedClassesInMethods.put(methodKey, new HashSet<String>());

    // insert argument types
    processType(Type.getReturnType(method.desc));
    for (Type type : Type.getArgumentTypes(method.desc)) {
        processType(type);/*from  w ww.  j a  v a  2 s  .c o  m*/
    }

    Interpreter interpreter = new BasicGuesser() {
        @Override
        public Value newOperation(AbstractInsnNode insn) {
            final int op = insn.getOpcode();
            String className = null;

            if (op == GETSTATIC) {
                className = ((FieldInsnNode) insn).owner.replace('/', '.');
            } else if (op == NEW) {
                className = Type.getObjectType(((TypeInsnNode) insn).desc).getClassName();
            }

            parent.registerDependencyForMethod(methodKey, className);
            return super.newOperation(insn);
        }

        @Override
        public Value unaryOperation(AbstractInsnNode insn, Value value) throws AnalyzerException {
            if (insn.getOpcode() == ARETURN) {
                if (methodKey.equals(GET_HANDLE) || methodKey.equals(GET_NODE_HANDLE)) {
                    RuntimeGuessValue guessedValue = (RuntimeGuessValue) value;
                    Type type = guessedValue.getType();

                    if (type != null && guessedValue != RuntimeGuessValue.NULL_CONSTANT) {
                        parent.classInfo.directHandle = type.getClassName();
                    }
                }
            }
            return super.unaryOperation(insn, value);
        }

        @Override
        public Value naryOperation(AbstractInsnNode insn, List values) throws AnalyzerException {
            if (insn instanceof MethodInsnNode) {
                MethodInsnNode minsn = (MethodInsnNode) insn;
                final int opCode = minsn.getOpcode();
                if (minsn.desc.endsWith(")Ljava/lang/Class;") && (minsn.name.equals("class$")
                        || (minsn.owner.equals("java/lang/Class") && minsn.name.equals("forName"))
                        || (minsn.owner.endsWith("ClassLoader") && minsn.name.equals("loadClass")))) {
                    // pattern for class loading
                    RuntimeGuessValue guessedValue = (RuntimeGuessValue) values
                            .get(opCode == Opcodes.INVOKESTATIC ? 0 : 1);
                    String className = (String) guessedValue.getValue();

                    if (className != null) {
                        return new RuntimeGuessValue(Type.getObjectType("java/lang/Class"), className);
                    }
                } else if (HANDLE_SOURCES.contains(minsn.owner)
                        && minsn.desc.equals("(Ljava/lang/Class;)Lde/jiac/micro/core/IHandle;")
                        && (minsn.name.equals("getHandle") || minsn.name.equals("getScopeHandle"))) {
                    // pattern for obtaining a handle
                    RuntimeGuessValue guessedValue = (RuntimeGuessValue) values
                            .get(opCode == Opcodes.INVOKESTATIC ? 0 : 1);
                    String className = (String) guessedValue.getValue();

                    if (className != null) {
                        obtainedHandles.add(className);
                        parent.registerDependencyForMethod(methodKey, className);
                        String internalName = className.replace('.', '/');
                        return new RuntimeGuessValue(Type.getObjectType(internalName), null);
                    }
                } else if (HANDLE_SOURCES.contains(minsn.owner) && minsn.name.equals("addHandle")
                        && minsn.desc.equals("(Lde/jiac/micro/core/IHandle;)V")) {
                    // pattern for adding a handle explicitly
                    RuntimeGuessValue guessValue = (RuntimeGuessValue) values.get(1);
                    Type type = guessValue.getType();

                    if (type != null) {
                        parent.registerDependencyForMethod(methodKey, type.getClassName());
                        parent.classInfo.indirectHandles.add(type.getClassName());
                    }
                }
            }

            return super.naryOperation(insn, values);
        }
    };

    Analyzer a = new Analyzer(interpreter);
    try {
        a.analyze(parent.owner, method);
    } catch (AnalyzerException e) {
        e.printStackTrace();
    }

    if (obtainedHandles.size() > 0) {
        ci.referencedHandlesInMethods.put(methodKey, obtainedHandles);
    }
}

From source file:de.sanandrew.core.manpack.transformer.InstructionComparator.java

License:Creative Commons License

public static boolean insnEqual(AbstractInsnNode node1, AbstractInsnNode node2) {
    if (node1.getType() != node2.getType()) {
        return false;
    } else if (node1.getOpcode() != node2.getOpcode()) {
        return false;
    }//www  .  j  a v a2 s.c o m

    switch (node2.getType()) {
    case VAR_INSN:
        return varInsnEqual((VarInsnNode) node1, (VarInsnNode) node2);
    case TYPE_INSN:
        return typeInsnEqual((TypeInsnNode) node1, (TypeInsnNode) node2);
    case FIELD_INSN:
        return fieldInsnEqual((FieldInsnNode) node1, (FieldInsnNode) node2);
    case METHOD_INSN:
        return methodInsnEqual((MethodInsnNode) node1, (MethodInsnNode) node2);
    case LDC_INSN:
        return ldcInsnEqual((LdcInsnNode) node1, (LdcInsnNode) node2);
    case IINC_INSN:
        return iincInsnEqual((IincInsnNode) node1, (IincInsnNode) node2);
    case INT_INSN:
        return intInsnEqual((IntInsnNode) node1, (IntInsnNode) node2);
    default:
        return true;
    }
}

From source file:de.tuberlin.uebb.jbop.optimizer.arithmetic.ArithmeticExpressionInterpreter.java

License:Open Source License

private AbstractInsnNode getReplacement(final Number one, final Number two, final AbstractInsnNode op) {
    final int opcode = op.getOpcode();
    if (opcode >= IADD && opcode <= DADD) {
        return handleAdd(opcode, one, two);
    }/* w  w w .  j av a2  s . c  om*/
    if (opcode >= ISUB && opcode <= DSUB) {
        return handleSub(opcode, one, two);
    }
    if (opcode >= IMUL && opcode <= DMUL) {
        return handleMul(opcode, one, two);
    }
    if (opcode >= IDIV && opcode <= DDIV) {
        return handleDiv(opcode, one, two);
    }
    if (opcode == IOR || opcode == LOR) {
        return handleOr(opcode, one, two);
    }
    if (opcode == IXOR || opcode == LXOR) {
        return handleXOr(opcode, one, two);
    }
    if (opcode == IAND || opcode == LAND) {
        return handleAnd(opcode, one, two);
    }
    if (opcode == IUSHR || opcode == LUSHR) {
        return handleLogicalShiftRight(opcode, one, two);
    }
    if (opcode == ISHR || opcode == LSHR) {
        return handleArithmeticShiftRight(opcode, one, two);
    }
    if (opcode == ISHL || opcode == LSHL) {
        return handleShiftLeft(opcode, one, two);
    }
    return null;
}

From source file:de.tuberlin.uebb.jbop.optimizer.arithmetic.ArithmeticExpressionInterpreter.java

License:Open Source License

private boolean isArithmeticOp(final AbstractInsnNode op) {
    final int opcode = op.getOpcode();
    if (isDoubleArithmetic(opcode)) {
        return true;
    } else if (isIntArithmetic(opcode)) {
        return true;
    } else if (isFloatArithmetic(opcode)) {
        return true;
    } else if (isLongArithmetic(opcode)) {
        return true;
    }/*from  ww w .ja  v  a 2s .c om*/
    return false;
}

From source file:de.tuberlin.uebb.jbop.optimizer.array.AbstractLocalArrayOptimizer.java

License:Open Source License

/**
 * Register values.//  w  w w.  j  a va  2  s  .c o  m
 * 
 * @param currentNode
 *          the current node
 * @param knownArrays
 *          the known arrays
 * @return true, if successful
 * @throws JBOPClassException
 *           the jBOP class exception
 */
protected int registerValues(final AbstractInsnNode currentNode, final Map<Integer, Object> knownArrays)
        throws JBOPClassException {
    if (currentNode.getOpcode() == Opcodes.ASTORE) {
        return registerGetArray(currentNode, knownArrays);
    }
    return registerAdditionalValues(currentNode, knownArrays);
}

From source file:de.tuberlin.uebb.jbop.optimizer.array.AbstractLocalArrayOptimizer.java

License:Open Source License

/**
 * Register get array./*from w w  w  .j  a va 2 s  .  c  o  m*/
 * 
 * @param currentNode
 *          the current node
 * @param knownArrays
 *          the known arrays
 * @return true, if successful
 * @throws JBOPClassException
 *           the jBOP class exception
 */
protected int registerGetArray(final AbstractInsnNode currentNode, final Map<Integer, Object> knownArrays)
        throws JBOPClassException {
    final List<AbstractInsnNode> previous = new ArrayList<>();
    final List<AbstractInsnNode> previous2 = new ArrayList<>();
    AbstractInsnNode previous2x = currentNode;
    while (true) {
        final AbstractInsnNode previousx = NodeHelper.getPrevious(previous2x);
        if (previousx.getOpcode() != Opcodes.AALOAD) {
            knownArrays.remove(Integer.valueOf(NodeHelper.getVarIndex(currentNode)));
            return 0;
        }
        previous.add(previousx);
        previous2x = NodeHelper.getPrevious(previousx);
        if (!NodeHelper.isNumberNode(previous2x)) {
            knownArrays.remove(Integer.valueOf(NodeHelper.getVarIndex(currentNode)));
            return 0;
        }
        previous2.add(previous2x);
        final AbstractInsnNode previous2xtmp = NodeHelper.getPrevious(previous2x);
        if ((previous2xtmp instanceof FieldInsnNode) || NodeHelper.isAload(previous2xtmp)) {
            break;
        }
    }
    final AbstractInsnNode previous3 = NodeHelper.getPrevious(previous2.get(previous2.size() - 1));
    Object array;
    if (previous3 instanceof VarInsnNode) {
        array = knownArrays.get(Integer.valueOf(((VarInsnNode) previous3).var));
        if (array == null) {
            knownArrays.remove(Integer.valueOf(NodeHelper.getVarIndex(currentNode)));
            return 0;
        }
    } else {
        if (!(previous3 instanceof FieldInsnNode)) {
            knownArrays.remove(Integer.valueOf(NodeHelper.getVarIndex(currentNode)));
            return 0;
        }
        final AbstractInsnNode previous4 = NodeHelper.getPrevious(previous3);
        if (!NodeHelper.isAload0(previous4)) {
            knownArrays.remove(Integer.valueOf(NodeHelper.getVarIndex(currentNode)));
            return 0;
        }
        final String fieldName = ((FieldInsnNode) previous3).name;

        array = ClassAccessor.getCurrentValue(input, fieldName);
    }
    final Integer varIndex = Integer.valueOf(((VarInsnNode) currentNode).var);

    for (int i = previous2.size() - 1; i >= 0; i--) {
        int index1;
        if (previous2.size() <= i) {
            index1 = 0;
        } else {
            final Number arrIndex = NodeHelper.getNumberValue(previous2.get(i));
            index1 = arrIndex.intValue();
        }
        array = Array.get(array, index1);
    }
    knownArrays.put(varIndex, array);
    return 1;
}

From source file:de.tuberlin.uebb.jbop.optimizer.array.LocalArrayLengthInliner.java

License:Open Source License

/**
 * Registers values for local arrays that are created via NEWARRAY / ANEWARRAY or MULTIANEWARRAY.
 * /*from  w w  w.  j a v  a 2  s  .  com*/
 * @param currentNode
 *          the current node
 * @param knownArrays
 *          the known arrays
 * @return true, if successful
 */
@Override
protected int registerAdditionalValues(final AbstractInsnNode currentNode, //
        final Map<Integer, Object> knownArrays) {
    final int opcode = currentNode.getOpcode();
    if (!((opcode == Opcodes.NEWARRAY) || (opcode == Opcodes.ANEWARRAY)
            || (opcode == Opcodes.MULTIANEWARRAY))) {
        return 0;
    }
    int dims = 1;
    if (currentNode.getOpcode() == Opcodes.MULTIANEWARRAY) {
        final MultiANewArrayInsnNode node = (MultiANewArrayInsnNode) currentNode;
        dims = node.dims;
    }
    final int sizes[] = new int[dims];
    AbstractInsnNode previous = currentNode;
    for (int i = 0; i < dims; ++i) {
        previous = NodeHelper.getPrevious(previous);
        if (!NodeHelper.isIntNode(previous)) {
            return 0;
        }
        try {
            final int value = NodeHelper.getNumberValue(previous).intValue();
            sizes[i] = value;
        } catch (final NotANumberException nane) {
            return 0;
        }
    }
    final AbstractInsnNode next = NodeHelper.getNext(currentNode);
    if (!(next instanceof VarInsnNode)) {
        return 0;
    }
    final int index = ((VarInsnNode) next).var;
    knownArrays.put(Integer.valueOf(index), Array.newInstance(Object.class, sizes));
    return 2;
}

From source file:de.tuberlin.uebb.jbop.optimizer.controlflow.ConstantIfInliner.java

License:Open Source License

private boolean handleNullInstruction(final AbstractInsnNode currentNode, final AbstractInsnNode node1,
        final InsnList list, final Iterator<AbstractInsnNode> iterator) throws JBOPClassException {
    if ((currentNode.getOpcode() == Opcodes.IFNULL) || (currentNode.getOpcode() == Opcodes.IFNONNULL)) {
        final boolean eval;
        if (node1.getOpcode() == Opcodes.ACONST_NULL) {
            if (!checkNullInstruction(node1, currentNode, list, iterator)) {
                return false;
            }/*ww  w .j a v  a  2  s  . co  m*/
            eval = evalSingleOpValue(null, currentNode.getOpcode());
        } else {
            final AbstractInsnNode node2 = NodeHelper.getPrevious(node1);
            if (!checkNumberInstruction(node1, node2, currentNode, list, iterator)) {
                return false;
            }
            // doesn't work for multiarrays yet
            final AbstractInsnNode node3 = NodeHelper.getPrevious(node2);
            final AbstractInsnNode node4 = NodeHelper.getPrevious(node3);
            boolean isNonNullArrayValue = false;
            if (arrayValue != null) {
                for (final NonNullArrayValue nonNullarrayValue : arrayValue.getNonNullArrayValues()) {
                    if (nonNullarrayValue.is(node4, node3, Arrays.asList(node2), Arrays.asList(node1))) {
                        isNonNullArrayValue = true;
                        break;
                    }
                }
            }
            if (!isNonNullArrayValue) {
                return false;
            }
            if (node2 != null) {
                list.remove(node2);
            }
            if (node3 != null) {
                list.remove(node3);
            }
            if (node4 != null) {
                list.remove(node4);
            }
            eval = evalSingleOpValue(NONNULL, currentNode.getOpcode());
        }
        removeNodes(currentNode, node1, null, null, list, iterator, eval);
        return true;
    }
    return false;
}

From source file:de.tuberlin.uebb.jbop.optimizer.controlflow.ConstantIfInliner.java

License:Open Source License

private boolean checkNumberInstruction(final AbstractInsnNode node1, final AbstractInsnNode node2,
        final AbstractInsnNode currentNode, final InsnList list, final Iterator<AbstractInsnNode> iterator)
        throws JBOPClassException {
    if ((NodeHelper.getFieldname(node1) != null) && (NodeHelper.getVarIndex(node2) == 0)) {
        final Object currentValue = ClassAccessor.getCurrentValue(inputObject, NodeHelper.getFieldname(node1));
        if (currentValue == null) {
            return false;
        }/*ww  w .  j  ava  2 s .  c  om*/
        removeNodes(currentNode, node1, node2, null, list, iterator,
                evalSingleOpValue(NONNULL, currentNode.getOpcode()));
        return false;
    }
    return true;
}