Example usage for org.objectweb.asm Label Label

List of usage examples for org.objectweb.asm Label Label

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.*
  5. Label
  6. Label

Introduction

In this page you can find the example usage for org.objectweb.asm Label Label.

Prototype

public Label()

Source Link

Document

Constructs a new label.

Usage

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

protected void generateEncodeSequenceValue(Class<?> javaClass, LocalVariable nextVar, MethodVisitor mv,
        boolean required, int outputStreamVar, Class<?> componentJavaClass, TypeDef type, Schema schema,
        String genClassInternalName, String fieldIdentifier, String debugValueLabel, boolean javaClassCodec)
        throws IllegalArgumentException {

    // PENDING: merge the two if-cases, and reuse common code blocks (see generateDecodeSquenceValue)
    if (javaClass.isArray()) {
        int sequenceVar = nextVar.next();
        mv.visitInsn(DUP);/*from  www .  jav  a2 s . com*/
        mv.visitVarInsn(ASTORE, sequenceVar);
        int lengthVar = nextVar.next();
        Label endLabel = new Label();
        if (required) {
            mv.visitInsn(ARRAYLENGTH);
            mv.visitInsn(DUP);
            mv.visitVarInsn(ISTORE, lengthVar);
            mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeUInt32",
                    "(Lcom/cinnober/msgcodec/io/ByteSink;I)V", false);
        } else {
            Label nonNullLabel = new Label();
            mv.visitInsn(DUP);
            mv.visitJumpInsn(IFNONNULL, nonNullLabel);
            // null
            mv.visitInsn(POP);
            mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeNull",
                    "(Lcom/cinnober/msgcodec/io/ByteSink;)V", false);
            mv.visitJumpInsn(GOTO, endLabel);
            // not null
            mv.visitLabel(nonNullLabel);
            // PENDING: mv.visitFrame?
            mv.visitInsn(ARRAYLENGTH);
            mv.visitInsn(DUP);
            mv.visitVarInsn(ISTORE, lengthVar);
            mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeUInt32",
                    "(Lcom/cinnober/msgcodec/io/ByteSink;I)V", false);
        }
        // for loop
        int loopVar = nextVar.next();
        mv.visitInsn(ICONST_0);
        mv.visitVarInsn(ISTORE, loopVar);
        Label loopLabel = new Label();
        mv.visitLabel(loopLabel);
        // PENDING: mv.visitFrame?
        mv.visitVarInsn(ILOAD, loopVar);
        mv.visitVarInsn(ILOAD, lengthVar);
        mv.visitJumpInsn(IF_ICMPGE, endLabel);
        mv.visitVarInsn(ALOAD, outputStreamVar);
        mv.visitVarInsn(ALOAD, sequenceVar);
        mv.visitVarInsn(ILOAD, loopVar);
        if (componentJavaClass == byte.class || componentJavaClass == boolean.class) {
            mv.visitInsn(BALOAD);
        } else if (componentJavaClass == short.class) {
            mv.visitInsn(SALOAD);
        } else if (componentJavaClass == int.class) {
            mv.visitInsn(IALOAD);
        } else if (componentJavaClass == long.class) {
            mv.visitInsn(LALOAD);
        } else if (componentJavaClass == float.class) {
            mv.visitInsn(FALOAD);
        } else if (componentJavaClass == double.class) {
            mv.visitInsn(DALOAD);
        } else if (componentJavaClass == char.class) {
            mv.visitInsn(CALOAD);
        } else {
            mv.visitInsn(AALOAD);
            mv.visitTypeInsn(CHECKCAST, Type.getInternalName(componentJavaClass));
        }

        // encode the element
        TypeDef.Sequence seqType = (TypeDef.Sequence) type;
        generateEncodeValue(mv, outputStreamVar, nextVar, true, seqType.getComponentType(), componentJavaClass,
                null, schema, genClassInternalName, fieldIdentifier, debugValueLabel + ".component",
                javaClassCodec);

        mv.visitIincInsn(loopVar, 1);
        mv.visitJumpInsn(GOTO, loopLabel);
        mv.visitLabel(endLabel);
        // PENDING: mv.visitFrame?

    } else if (javaClass == List.class) {
        int sequenceVar = nextVar.next();
        mv.visitInsn(DUP);
        mv.visitVarInsn(ASTORE, sequenceVar);
        int lengthVar = nextVar.next();
        Label endLabel = new Label();
        if (required) {
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "size", "()I", true);
            mv.visitInsn(DUP);
            mv.visitVarInsn(ISTORE, lengthVar);
            mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeUInt32",
                    "(Lcom/cinnober/msgcodec/io/ByteSink;I)V", false);
        } else {
            Label nonNullLabel = new Label();
            mv.visitInsn(DUP);
            mv.visitJumpInsn(IFNONNULL, nonNullLabel);
            // null
            mv.visitInsn(POP);
            mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeNull",
                    "(Lcom/cinnober/msgcodec/io/ByteSink;)V", false);
            mv.visitJumpInsn(GOTO, endLabel);
            // not null
            mv.visitLabel(nonNullLabel);
            // PENDING: mv.visitFrame?
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "size", "()I", true);
            mv.visitInsn(DUP);
            mv.visitVarInsn(ISTORE, lengthVar);
            mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeUInt32",
                    "(Lcom/cinnober/msgcodec/io/ByteSink;I)V", false);
        }
        // for loop, using iterator
        int iteratorVar = nextVar.next();
        mv.visitVarInsn(ALOAD, sequenceVar);
        mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "iterator", "()Ljava/util/Iterator;", true);
        mv.visitVarInsn(ASTORE, iteratorVar);
        Label loopLabel = new Label();
        mv.visitLabel(loopLabel);
        // PENDING: mv.visitFrame?
        mv.visitVarInsn(ALOAD, iteratorVar);
        mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Iterator", "hasNext", "()Z", true);
        mv.visitJumpInsn(IFEQ, endLabel);
        mv.visitVarInsn(ALOAD, outputStreamVar);
        mv.visitVarInsn(ALOAD, iteratorVar);
        mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Iterator", "next", "()Ljava/lang/Object;", true);
        if (componentJavaClass.isPrimitive()) {
            mv.visitTypeInsn(CHECKCAST, Type.getInternalName(box(componentJavaClass)));
            unbox(mv, componentJavaClass);
        } else {
            mv.visitTypeInsn(CHECKCAST, Type.getInternalName(componentJavaClass));
        }

        // encode the element
        TypeDef.Sequence seqType = (TypeDef.Sequence) type;
        generateEncodeValue(mv, outputStreamVar, nextVar, true, seqType.getComponentType(), componentJavaClass,
                null, schema, genClassInternalName, fieldIdentifier, debugValueLabel + ".component",
                javaClassCodec);

        mv.visitJumpInsn(GOTO, loopLabel);
        mv.visitLabel(endLabel);
        // PENDING: mv.visitFrame?
    } else {
        throw new IllegalArgumentException("Illegal sequence javaClass: " + javaClass);
    }
}

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

protected void generateEncodeTimeValue(TypeDef.Time type, Class<?> javaClass, boolean required,
        MethodVisitor mv) throws RuntimeException {
    if (javaClass == long.class || javaClass == Long.class) {
        generateEncodeInt64Value(required, mv);
    } else if (javaClass == int.class || javaClass == Integer.class) {
        generateEncodeInt32Value(required, mv);
    } else if (javaClass == Date.class) {

        Label nullLabel = new Label();
        Label endLabel = new Label();
        if (!required) {
            mv.visitInsn(DUP);/*from www . j a  va  2 s .co m*/
            mv.visitJumpInsn(IFNULL, nullLabel);
        }

        // not null
        mv.visitMethodInsn(INVOKEVIRTUAL, "java/util/Date", "getTime", "()J", false);
        // handle differences in UNIT and EPOCH
        long epochOffset = DateUtil.getEpochOffset(type.getEpoch());
        long timeInMillis = DateUtil.getTimeInMillis(type.getUnit());
        // wireTime = (dateTime - epochOffset) / timeUnitInMillis);
        if (epochOffset != 0) {
            mv.visitLdcInsn(epochOffset);
            mv.visitInsn(LSUB);
        }
        if (timeInMillis != 1) {
            mv.visitLdcInsn(timeInMillis);
            mv.visitInsn(LDIV);
        }
        box(mv, long.class);
        mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeInt64Null",
                "(Lcom/cinnober/msgcodec/io/ByteSink;Ljava/lang/Long;)V", false);

        if (!required) {
            mv.visitJumpInsn(GOTO, endLabel);
            mv.visitLabel(nullLabel);
            mv.visitInsn(POP);
            mv.visitInsn(ACONST_NULL);
            mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeInt64Null",
                    "(Lcom/cinnober/msgcodec/io/ByteSink;Ljava/lang/Long;)V", false);
            mv.visitLabel(endLabel);
        }
    } else {
        throw new IllegalArgumentException("Illegal time javaClass: " + javaClass);
    }
}

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

protected void generateEncodeEnumValue(TypeDef.Enum enumType, String genClassInternalName,
        String fieldIdentifier, LocalVariable nextVar, Class<?> javaClass, boolean required, MethodVisitor mv,
        String debugValueLabel) throws IllegalArgumentException {

    Label writeValueLabel = new Label();

    // Make sure that no unsupported javaClass is used for an enum
    if (javaClass != int.class && javaClass != Integer.class && (javaClass == null || !javaClass.isEnum())) {
        throw new IllegalArgumentException("Illegal enum javaClass: " + javaClass);
    }//from  ww  w .  j a v  a2 s  . c om

    // If null do not look it up
    if (!required) {
        Label lookupIdLabel = new Label();
        mv.visitInsn(DUP);
        mv.visitJumpInsn(IFNONNULL, lookupIdLabel);

        // null
        mv.visitInsn(POP);
        mv.visitInsn(ACONST_NULL);
        mv.visitJumpInsn(GOTO, writeValueLabel);

        // not null
        mv.visitLabel(lookupIdLabel);
    }

    // SymbolMapping
    if (required && !javaClass.isEnum()) {
        box(mv, int.class);
    }
    mv.visitVarInsn(ALOAD, 0);
    mv.visitFieldInsn(GETFIELD, genClassInternalName, "symbolMapping_" + fieldIdentifier,
            "Lcom/cinnober/msgcodec/SymbolMapping;");
    mv.visitInsn(SWAP);
    mv.visitMethodInsn(INVOKEINTERFACE, "com/cinnober/msgcodec/SymbolMapping", "getId",
            "(Ljava/lang/Object;)Ljava/lang/Integer;", true);

    // Write the value
    mv.visitLabel(writeValueLabel);
    if (required) {
        unbox(mv, Integer.class); // TODO: Should null check before this and throw exception since there was no mapping
    }
    generateEncodeInt32Value(required, mv);

    //        if (javaClass.isEnum()) {
    //            Label endLabel = new Label();
    //            if (!required) {
    //                Label nonNullLabel = new Label();
    //                mv.visitInsn(DUP);
    //                mv.visitJumpInsn(IFNONNULL, nonNullLabel);
    //                // null
    //                mv.visitInsn(POP);
    //                mv.visitInsn(ACONST_NULL);
    //                mv.visitMethodInsn(INVOKESTATIC, blinkOutputIName, "writeInt32Null",
    //                        "(Lcom/cinnober/msgcodec/io/ByteSink;Ljava/lang/Integer;)V", false);
    //                mv.visitJumpInsn(GOTO, endLabel);
    //                // not null
    //                mv.visitLabel(nonNullLabel);
    //            }
    //            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Enum", "ordinal", "()I", false);
    //            //switch
    //            EnumSymbols enumSymbols = new EnumSymbols(enumType, javaClass);
    //            Enum[] enumValues = ((Class<Enum>)javaClass).getEnumConstants();
    //            int[] ordinals = new int[enumValues.length];
    //            Label[] labels = new Label[enumValues.length];
    //            for (int i=0; i<enumValues.length; i++) {
    //                ordinals[i] = i;
    //                labels[i] = new Label();
    //            }
    //            Label defaultLabel = new Label();
    //            Label writeLabel = new Label();
    //            int symbolIdVar = nextVar.next();
    //            mv.visitLookupSwitchInsn(defaultLabel, ordinals, labels);
    //            for (int i=0; i<enumValues.length; i++) {
    //                mv.visitLabel(labels[i]);
    //                Symbol symbol = enumSymbols.getSymbol(enumValues[i]);
    //                if (symbol != null) {
    //                    mv.visitLdcInsn(symbol.getId());
    //                    mv.visitJumpInsn(GOTO, writeLabel);
    //                } else {
    //                    mv.visitLdcInsn(debugValueLabel);
    //                    mv.visitVarInsn(ALOAD, symbolIdVar);
    //                    mv.visitMethodInsn(INVOKESTATIC, baseclassIName, "unmappableEnumSymbolValue",
    //                            "(Ljava/lang/String;Ljava/lang/Enum;)Ljava/lang/IllegalArgumentException;", false);
    //                    mv.visitInsn(ATHROW);
    //                }
    //            }
    //            mv.visitLabel(defaultLabel);
    //            mv.visitTypeInsn(NEW, "java/lang/RuntimeException");
    //            mv.visitInsn(DUP);
    //            mv.visitLdcInsn("Should not happen: reached generated switch default case for value " + debugValueLabel);
    //            mv.visitMethodInsn(INVOKESPECIAL, "java/lang/RuntimeException", "<init>", "(Ljava/lang/String;)V", false);
    //            mv.visitInsn(ATHROW);
    //
    //            // write
    //            mv.visitLabel(writeLabel);
    //            if (!required) {
    //                box(mv, int.class);
    //            }
    //            generateEncodeInt32Value(required, mv);
    //            // end
    //            mv.visitLabel(endLabel);
    //        } else if (javaClass == int.class || javaClass == Integer.class) {
    //            generateEncodeInt32Value(required, mv);
    //        } else {
    //            throw new IllegalArgumentException("Illegal enum javaClass: " + javaClass);
    //        }
}

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

/**
 * Generate value decoding using the blink input.
 *
 * <p>Defaults to <code>readUInt16[Null].</code>
 *
 * @param required true if the field is required, otherwise false.
 * @param mv the method visitor, not null.
 * @see #generateDecodeValue/*  ww w.  ja v a 2 s. c  om*/
 */
protected void generateDecodeCharacterValue(boolean required, MethodVisitor mv) {
    if (required) {
        mv.visitMethodInsn(INVOKESTATIC, blinkInputIName, "readUInt16",
                "(Lcom/cinnober/msgcodec/io/ByteSource;)S", false);
        mv.visitInsn(I2C);
    } else {
        mv.visitMethodInsn(INVOKESTATIC, blinkInputIName, "readUInt16Null",
                "(Lcom/cinnober/msgcodec/io/ByteSource;)Ljava/lang/Short;", false);
        Label nullLabel = new Label();
        mv.visitInsn(DUP);
        mv.visitJumpInsn(IFNULL, nullLabel);
        unbox(mv, Short.class);
        mv.visitInsn(I2C);
        box(mv, Character.class);
        mv.visitLabel(nullLabel);
        mv.visitTypeInsn(CHECKCAST, Type.getInternalName(Character.class));
    }
}

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

protected void generateDecodeTimeValue(TypeDef.Time type, Class<?> javaClass, boolean required,
        MethodVisitor mv, LocalVariable nextVar) throws IllegalArgumentException {
    if (javaClass == long.class || javaClass == Long.class) {
        generateDecodeInt64Value(required, mv);
    } else if (javaClass == int.class || javaClass == Integer.class) {
        generateDecodeInt32Value(required, mv);
    } else if (javaClass == Date.class) {

        int timeVar = nextVar.next();
        nextVar.next(); // note: 2 variable slots
        Label endLabel = new Label();
        if (required) {
            generateDecodeInt64Value(true, mv);
        } else {// w  w w. j a v  a2s.c  o m
            generateDecodeInt64Value(false, mv);
            mv.visitInsn(DUP);
            Label nonNullLabel = new Label();
            mv.visitJumpInsn(IFNONNULL, nonNullLabel);
            // null
            mv.visitTypeInsn(CHECKCAST, "java/util/Date");
            mv.visitJumpInsn(GOTO, endLabel);
            // not null
            mv.visitLabel(nonNullLabel);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J", false);
        }

        mv.visitVarInsn(LSTORE, timeVar);
        mv.visitTypeInsn(NEW, "java/util/Date");
        mv.visitInsn(DUP);
        mv.visitVarInsn(LLOAD, timeVar);
        // handle differences in UNIT and EPOCH
        long epochOffset = DateUtil.getEpochOffset(type.getEpoch());
        long timeInMillis = DateUtil.getTimeInMillis(type.getUnit());
        // dateTime = wireTime * timeUnitInMillis + epochOffset;
        if (timeInMillis != 1) {
            mv.visitLdcInsn(timeInMillis);
            mv.visitInsn(LMUL);
        }
        if (epochOffset != 0) {
            mv.visitLdcInsn(epochOffset);
            mv.visitInsn(LADD);
        }

        mv.visitMethodInsn(INVOKESPECIAL, "java/util/Date", "<init>", "(J)V", false);

        if (!required) {
            // end
            mv.visitLabel(endLabel);
        }
    } else {
        throw new IllegalArgumentException("Illegal time javaClass: " + javaClass);
    }
}

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

/**
 * @see #generateDecodeInt32Value(boolean, org.objectweb.asm.MethodVisitor) 
 *///from w  w w . j a  v  a 2  s .  c  o  m
protected void generateDecodeEnumValue(boolean required, MethodVisitor mv, TypeDef type,
        String genClassInternalName, String fieldIdentifier, LocalVariable nextVar, Class<?> javaClass,
        String debugValueLabel) throws IllegalArgumentException {

    Label endLabel = new Label();
    if (required) {
        generateDecodeInt32Value(true, mv);
        box(mv, Integer.class);
    } else {
        generateDecodeInt32Value(false, mv);
        mv.visitInsn(DUP);
        mv.visitJumpInsn(IFNULL, endLabel);

        //            Label nonNullLabel = new Label();
        //            mv.visitJumpInsn(IFNONNULL, nonNullLabel);
        //            mv.visitTypeInsn(CHECKCAST, Type.getInternalName(javaClass));
        //            mv.visitJumpInsn(GOTO, endLabel);

        // not null
        //            mv.visitLabel(nonNullLabel);
        //            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false); // unbox(mv, Integer.class);
    }

    // SymbolMapping
    mv.visitVarInsn(ALOAD, 0);
    mv.visitFieldInsn(GETFIELD, genClassInternalName, "symbolMapping_" + fieldIdentifier,
            "Lcom/cinnober/msgcodec/SymbolMapping;");
    mv.visitInsn(SWAP);
    mv.visitMethodInsn(INVOKEINTERFACE, "com/cinnober/msgcodec/SymbolMapping", "lookup",
            "(Ljava/lang/Integer;)Ljava/lang/Object;", true);

    //        // switch
    //        TypeDef.Enum enumType = (TypeDef.Enum) type;
    //        List<Symbol> symbols = enumType.getSymbols();
    //        int numSymbols = symbols.size();
    //        int[] ids = new int[numSymbols];
    //        Label[] labels = new Label[numSymbols];
    //        for (int i=0; i<numSymbols; i++) {
    //            ids[i] = symbols.get(i).getId();
    //            labels[i] = new Label();
    //        }
    //        Label defaultLabel = new Label();
    //        int symbolIdVar = nextVar.next();
    //        mv.visitInsn(DUP);
    //        mv.visitVarInsn(ISTORE, symbolIdVar);
    //        EnumSymbols enumSymbols = null;
    //        if (javaClass.isEnum()) {
    //            enumSymbols = new EnumSymbols(enumType, javaClass);
    //        }
    //        mv.visitLookupSwitchInsn(defaultLabel, ids, labels);
    //        for (int i=0; i<numSymbols; i++) {
    //            boolean addGotoEnd = true;
    //            mv.visitLabel(labels[i]);
    //            if (javaClass.isEnum()) {
    //                Enum enumValue = enumSymbols.getEnum(ids[i]);
    //                if (enumValue != null) {
    //                    //mv.visitLdcInsn(Type.getType(javaClass));
    //                    mv.visitFieldInsn(GETSTATIC, Type.getInternalName(javaClass),
    //                            enumValue.name(),
    //                            Type.getDescriptor(javaClass));
    //                } else {
    //                    mv.visitLdcInsn(debugValueLabel);
    //                    mv.visitLdcInsn(ids[i]);
    //                    mv.visitLdcInsn(Type.getType(javaClass));
    //                    mv.visitMethodInsn(INVOKESTATIC, baseclassIName, "unmappableEnumSymbolId",
    //                            "(Ljava/lang/String;ILjava/lang/Class;)Lcom/cinnober/msgcodec/DecodeException;", false);
    //                    mv.visitInsn(ATHROW);
    //                    addGotoEnd = false;
    //                }
    //            } else if (javaClass == int.class || javaClass == Integer.class) {
    //                mv.visitLdcInsn(ids[i]);
    //                if (!required) {
    //                    box(mv, Integer.class);
    //                }
    //            } else {
    //                throw new IllegalArgumentException("Illegal enum javaClass: " + javaClass);
    //            }
    //            if (addGotoEnd) {
    //                mv.visitJumpInsn(GOTO, endLabel);
    //            }
    //        }
    //        mv.visitLabel(defaultLabel);
    //        mv.visitLdcInsn(debugValueLabel);
    //        mv.visitVarInsn(ILOAD, symbolIdVar);
    //        mv.visitMethodInsn(INVOKESTATIC, baseclassIName, "unknownEnumSymbol",
    //                "(Ljava/lang/String;I)Lcom/cinnober/msgcodec/DecodeException;", false);
    //        mv.visitInsn(ATHROW);

    // end
    mv.visitLabel(endLabel);

    if (!javaClass.isEnum()) {
        mv.visitTypeInsn(CHECKCAST, Type.getInternalName(Integer.class));
        if (required) {
            unbox(mv, Integer.class);
        }
    } else {
        mv.visitTypeInsn(CHECKCAST, Type.getInternalName(javaClass));
    }
}

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

protected void generateDecodeRefValue(GroupDef refGroup, boolean required, MethodVisitor mv, int byteSourceVar,
        String genClassInternalName, Class<?> javaClass, TypeDef type, boolean javaClassCodec)
        throws IllegalArgumentException {
    if (refGroup != null) {
        String groupDescriptor = getTypeDescriptor(javaClass, javaClassCodec);
        if (required) {
            mv.visitInsn(POP); // input stream
            mv.visitVarInsn(ALOAD, 0);//from   ww  w.j a va  2  s. c om
            mv.visitVarInsn(ALOAD, byteSourceVar);
            mv.visitMethodInsn(INVOKEVIRTUAL, genClassInternalName, "readStaticGroup_" + refGroup.getName(),
                    "(Lcom/cinnober/msgcodec/io/ByteSource;)" + groupDescriptor, false);
        } else {
            mv.visitMethodInsn(INVOKESTATIC, blinkInputIName, "readPresenceByte",
                    "(Lcom/cinnober/msgcodec/io/ByteSource;)Z", false);
            Label nonNullLabel = new Label();
            Label endLabel = new Label();
            mv.visitJumpInsn(IFNE, nonNullLabel); // not false, i.e. true
            // null
            mv.visitInsn(ACONST_NULL);
            mv.visitJumpInsn(GOTO, endLabel);

            // not null
            mv.visitLabel(nonNullLabel);
            mv.visitFrame(F_SAME, 0, null, 0, null);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitVarInsn(ALOAD, byteSourceVar);
            mv.visitMethodInsn(INVOKEVIRTUAL, genClassInternalName, "readStaticGroup_" + refGroup.getName(),
                    "(Lcom/cinnober/msgcodec/io/ByteSource;)" + groupDescriptor, false);

            mv.visitLabel(endLabel);
            // PENDING: mv.visitFrame?
            mv.visitFrame(F_SAME, 0, null, 0, null);
        }
    } else {
        throw new IllegalArgumentException("Illegal reference: " + type);
    }
}

From source file:com.cinnober.msgcodec.blink.BaseByteCodeGenerator.java

License:Open Source License

protected void generateDecodeSequenceValue(Class<?> javaClass, LocalVariable nextVar, boolean required,
        MethodVisitor mv, Class<?> componentJavaClass, int byteSourceVar, TypeDef type, Schema schema,
        String genClassInternalName, String fieldIdentifier, String debugValueLabel, boolean javaClassCodec)
        throws IllegalArgumentException {
    if (!javaClass.isArray() && javaClass != List.class) {
        throw new IllegalArgumentException("Illegal sequence javaClass: " + javaClass);
    }//www .  ja v a  2s .  co m

    int lengthVar = nextVar.next();
    int sequenceVar = nextVar.next();
    Label finalEndLabel = new Label();
    if (required) {
        mv.visitMethodInsn(INVOKESTATIC, blinkInputIName, "readUInt32",
                "(Lcom/cinnober/msgcodec/io/ByteSource;)I", false);
        mv.visitVarInsn(ISTORE, lengthVar);
    } else {
        mv.visitMethodInsn(INVOKESTATIC, blinkInputIName, "readUInt32Null",
                "(Lcom/cinnober/msgcodec/io/ByteSource;)Ljava/lang/Integer;", false);
        mv.visitInsn(DUP);
        mv.visitJumpInsn(IFNULL, finalEndLabel);
        unbox(mv, Integer.class);
        mv.visitVarInsn(ISTORE, lengthVar);
    }

    if (javaClass.isArray()) {
        mv.visitVarInsn(ILOAD, lengthVar);
        generateNewArray(mv, componentJavaClass);
    } else {
        mv.visitTypeInsn(NEW, "java/util/ArrayList");
        mv.visitInsn(DUP);
        mv.visitVarInsn(ILOAD, lengthVar);
        mv.visitMethodInsn(INVOKESPECIAL, "java/util/ArrayList", "<init>", "(I)V", false);
    }
    mv.visitVarInsn(ASTORE, sequenceVar);

    // for loop
    Label endLabel = new Label();
    int loopVar = nextVar.next();
    mv.visitInsn(ICONST_0);
    mv.visitVarInsn(ISTORE, loopVar);
    Label loopLabel = new Label();
    mv.visitLabel(loopLabel);
    // PENDING: mv.visitFrame?
    mv.visitFrame(F_SAME, 0, null, 0, null);
    mv.visitVarInsn(ILOAD, loopVar);
    mv.visitVarInsn(ILOAD, lengthVar);
    mv.visitJumpInsn(IF_ICMPGE, endLabel);

    mv.visitVarInsn(ALOAD, sequenceVar);
    mv.visitVarInsn(ILOAD, loopVar);
    mv.visitVarInsn(ALOAD, byteSourceVar);

    // decode the element
    TypeDef.Sequence seqType = (TypeDef.Sequence) type;
    generateDecodeValue(mv, byteSourceVar, nextVar, true, seqType.getComponentType(), componentJavaClass, null,
            schema, genClassInternalName, fieldIdentifier, debugValueLabel + ".component", javaClassCodec);

    // store the value
    if (javaClass.isArray()) {
        generateArrayStore(mv, componentJavaClass);
    } else {
        mv.visitMethodInsn(INVOKEVIRTUAL, "java/util/ArrayList", "add", "(ILjava/lang/Object;)V", false);
    }

    mv.visitIincInsn(loopVar, 1);
    mv.visitJumpInsn(GOTO, loopLabel);
    mv.visitLabel(endLabel);
    mv.visitFrame(F_SAME, 0, null, 0, null);
    mv.visitVarInsn(ALOAD, sequenceVar);
    mv.visitLabel(finalEndLabel);
    mv.visitFrame(F_SAME, 0, null, 0, null);
    if (javaClass.isArray()) {
        mv.visitTypeInsn(CHECKCAST, Type.getInternalName(javaClass));
    }
}

From source file:com.develorium.metracer.asm.PatternMatchedMethodMutator.java

License:Apache License

@Override
protected void onMethodEnter() {
    // Class<?> runtimeClass = null;
    mv.visitInsn(ACONST_NULL);/*w w  w.  j a  v a2s.co m*/
    runtimeClassVariableIndex = newLocal(Type.getType("Ljava/lang/Class;"));
    mv.visitVarInsn(ASTORE, runtimeClassVariableIndex);

    mv.visitLabel(startFinally);
    // ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
    int systemClassLoaderVariableIndex = newLocal(Type.getType("Ljava/lang/ClassLoader;"));
    mv.visitMethodInsn(INVOKESTATIC, "java/lang/ClassLoader", "getSystemClassLoader",
            "()Ljava/lang/ClassLoader;", false);
    mv.visitVarInsn(ASTORE, systemClassLoaderVariableIndex);

    // runtimeClass = Class.forName("com.develorium.metracer.Runtime", true, systemClassLoader);
    mv.visitLdcInsn("com.develorium.metracer.Runtime");
    mv.visitInsn(ICONST_1);
    mv.visitVarInsn(ALOAD, systemClassLoaderVariableIndex);
    mv.visitMethodInsn(INVOKESTATIC, "java/lang/Class", "forName",
            "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;", false);
    mv.visitVarInsn(ASTORE, runtimeClassVariableIndex);

    // Class<?>[] traceEntryArgumentTypes = { Class.class, String.class, String[].class, Object[].class, boolean.class };
    mv.visitInsn(ICONST_5);
    mv.visitTypeInsn(ANEWARRAY, "java/lang/Class");
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_0);
    mv.visitLdcInsn(Type.getType("Ljava/lang/Class;"));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_1);
    mv.visitLdcInsn(Type.getType("Ljava/lang/String;"));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_2);
    mv.visitLdcInsn(Type.getType("[Ljava/lang/String;"));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_3);
    mv.visitLdcInsn(Type.getType("[Ljava/lang/Object;"));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_4);
    mv.visitFieldInsn(GETSTATIC, "java/lang/Boolean", "TYPE", "Ljava/lang/Class;");
    mv.visitInsn(AASTORE);
    int traceEntryArgumentTypesVariableIndex = newLocal(Type.getType("[Ljava/lang/Class;"));
    mv.visitVarInsn(ASTORE, traceEntryArgumentTypesVariableIndex);

    // Method traceEntryMethod = runtimeClass.getMethod("traceEntry", traceEntryArgumentTypes);
    mv.visitVarInsn(ALOAD, runtimeClassVariableIndex);
    mv.visitLdcInsn("traceEntry");
    mv.visitVarInsn(ALOAD, traceEntryArgumentTypesVariableIndex);
    mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getMethod",
            "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;", false);
    int traceEntryMethodVariableIndex = newLocal(Type.getType("Ljava/lang/reflect/Method;"));
    mv.visitVarInsn(ASTORE, traceEntryMethodVariableIndex);

    // String[] argumentNames = null;
    int argumentNamesVariableIndex = newLocal(Type.getType("[Ljava/lang/String;"));
    mv.visitInsn(ACONST_NULL);
    mv.visitVarInsn(ASTORE, argumentNamesVariableIndex);

    // String[] argumentValues = null;
    int argumentValuesVariableIndex = newLocal(Type.getType("[Ljava/lang/Object;"));
    mv.visitInsn(ACONST_NULL);
    mv.visitVarInsn(ASTORE, argumentValuesVariableIndex);

    Type[] argumentTypes = Type.getArgumentTypes(methodDesc);
    boolean areAnyArguments = argumentTypes != null && argumentTypes.length > 0;

    if (areAnyArguments) {
        // populate argumentNames array with names of method arguments
        mv.visitLdcInsn(new Integer(argumentTypes.length));
        mv.visitTypeInsn(ANEWARRAY, "java/lang/String");
        mv.visitVarInsn(ASTORE, argumentNamesVariableIndex);
        List<LocalVariableNode> localVariableNodes = method != null ? method.localVariables : null;
        TreeMap<Integer, String> localVariables = new TreeMap<Integer, String>();

        if (localVariableNodes != null) {
            for (LocalVariableNode node : localVariableNodes) {
                localVariables.put(node.index, node.name);
            }
        }

        for (int i = 0; i < argumentTypes.length; ++i) {
            int argIndex = isStatic ? i : i + 1;
            String localVariableName = localVariables.get(argIndex);
            String argumentName = localVariableName != null ? localVariableName : "$arg" + i;
            mv.visitVarInsn(ALOAD, argumentNamesVariableIndex);
            mv.visitLdcInsn(new Integer(i));
            mv.visitLdcInsn(argumentName);
            mv.visitInsn(AASTORE);
        }

        //populate argumentValues array with values of method arguments
        loadArgArray();
        mv.visitVarInsn(ASTORE, argumentValuesVariableIndex);
    }

    // Object[] traceEntryArgumentValues = { ?.class, "testMethod", argumentNames, argumentValues, isWithStackTraces };
    mv.visitInsn(ICONST_5);
    mv.visitTypeInsn(ANEWARRAY, "java/lang/Object");
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_0);
    mv.visitLdcInsn(Type.getType(String.format("L%1$s;", className)));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_1);
    mv.visitLdcInsn(methodName);
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_2);
    mv.visitVarInsn(ALOAD, argumentNamesVariableIndex);
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_3);
    mv.visitVarInsn(ALOAD, argumentValuesVariableIndex);
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_4);
    mv.visitInsn(isWithStackTraces ? ICONST_1 : ICONST_0);
    mv.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
    mv.visitInsn(AASTORE);
    int traceEntryArgumentValuesVariableIndex = newLocal(Type.getType("Ljava/lang/Object;"));
    mv.visitVarInsn(ASTORE, traceEntryArgumentValuesVariableIndex);

    // traceEntryMethod.invoke(null, traceEntryArgumentValues);
    mv.visitVarInsn(ALOAD, traceEntryMethodVariableIndex);
    mv.visitInsn(ACONST_NULL);
    mv.visitVarInsn(ALOAD, traceEntryArgumentValuesVariableIndex);
    mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/reflect/Method", "invoke",
            "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;", false);
    mv.visitInsn(POP);

    Label methodEnterEnd = new Label();
    mv.visitLabel(methodEnterEnd);

    Label methodEnterEndUltimate = new Label();
    mv.visitJumpInsn(GOTO, methodEnterEndUltimate);
    int exceptionVariableIndex = newLocal(Type.getType("[Ljava/lang/Throwable;"));
    Label methodEnterCatchBlock = new Label();
    mv.visitLabel(methodEnterCatchBlock);
    mv.visitVarInsn(ASTORE, exceptionVariableIndex);
    Label methodEnterCatchStart = new Label();
    Label methodEnterCatchEnd = new Label();
    mv.visitLabel(methodEnterCatchStart);
    mv.visitLabel(methodEnterCatchEnd);
    mv.visitLabel(methodEnterEndUltimate);

    mv.visitTryCatchBlock(startFinally, methodEnterEnd, methodEnterCatchBlock, "java/lang/Throwable");

    mv.visitLocalVariable("systemClassLoader", "Ljava/lang/ClassLoader;", null, startFinally, methodEnterEnd,
            systemClassLoaderVariableIndex);
    mv.visitLocalVariable("traceEntryArgumentTypes", "[Ljava/lang/Class;", null, startFinally, methodEnterEnd,
            traceEntryArgumentTypesVariableIndex);
    mv.visitLocalVariable("traceEntryMethod", "Ljava/lang/reflect/Method;", null, startFinally, methodEnterEnd,
            traceEntryMethodVariableIndex);
    mv.visitLocalVariable("argumentNames", "[Ljava/lang/String;", null, startFinally, methodEnterEnd,
            argumentNamesVariableIndex);
    mv.visitLocalVariable("argumentValues", "[Ljava/lang/Object;", null, startFinally, methodEnterEnd,
            argumentValuesVariableIndex);
    mv.visitLocalVariable("traceEntryArgumentValues", "[Ljava/lang/Object;", null, startFinally, methodEnterEnd,
            traceEntryArgumentValuesVariableIndex);
    mv.visitLocalVariable("e", "Ljava/lang/Throwable;", null, methodEnterCatchStart, methodEnterCatchEnd,
            exceptionVariableIndex);
}

From source file:com.develorium.metracer.asm.PatternMatchedMethodMutator.java

License:Apache License

private void injectTraceExit(int theOpcode) {
    // need to grab return value from a stack into local variable before establishing new try / catch frame,
    // otherwise VerifyError would be thrown
    boolean isReturnValueBoxed = false;
    int returnValueVariableIndex = newLocal(Type.getType("[Ljava/lang/Object;"));
    Label methodExitEarlyStart = new Label();
    mv.visitLabel(methodExitEarlyStart);

    if (theOpcode == RETURN) {
        visitInsn(ACONST_NULL);//from  ww w. j a va2 s  .co  m
    } else {
        switch (theOpcode) {
        case LRETURN:
        case DRETURN:
        case FRETURN:
        case IRETURN:
            box(Type.getReturnType(methodDesc));
            isReturnValueBoxed = true;
            break;
        }
    }

    mv.visitVarInsn(ASTORE, returnValueVariableIndex);

    Label methodExitStart = new Label();
    mv.visitLabel(methodExitStart);

    // Class<?>[] traceExitArgumentTypes = { Class.class, String.class, boolean.class, Object.class };
    mv.visitInsn(ICONST_4);
    mv.visitTypeInsn(ANEWARRAY, "java/lang/Class");
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_0);
    mv.visitLdcInsn(Type.getType("Ljava/lang/Class;"));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_1);
    mv.visitLdcInsn(Type.getType("Ljava/lang/String;"));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_2);
    mv.visitFieldInsn(GETSTATIC, "java/lang/Boolean", "TYPE", "Ljava/lang/Class;");
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_3);
    mv.visitLdcInsn(Type.getType("Ljava/lang/Object;"));
    mv.visitInsn(AASTORE);
    int traceExitArgumentTypesVariableIndex = newLocal(Type.getType("[Ljava/lang/Class;"));
    mv.visitVarInsn(ASTORE, traceExitArgumentTypesVariableIndex);

    // Method traceExitMethod = runtimeClass.getMethod("traceExit", traceExitArgumentTypes);
    mv.visitVarInsn(ALOAD, runtimeClassVariableIndex);
    mv.visitLdcInsn("traceExit");
    mv.visitVarInsn(ALOAD, traceExitArgumentTypesVariableIndex);
    mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getMethod",
            "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;", false);
    int traceExitMethodVariableIndex = newLocal(Type.getType("Ljava/lang/reflect/Method;"));
    mv.visitVarInsn(ASTORE, traceExitMethodVariableIndex);

    // Object[] traceExitArgumentValues = { ?.class, "testMethod", isVoid, rv };
    mv.visitInsn(ICONST_4);
    mv.visitTypeInsn(ANEWARRAY, "java/lang/Object");
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_0);
    mv.visitLdcInsn(Type.getType(String.format("L%1$s;", className)));
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_1);
    mv.visitLdcInsn(methodName);
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_2);
    mv.visitInsn(theOpcode == RETURN ? ICONST_1 : ICONST_0);
    mv.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
    mv.visitInsn(AASTORE);
    mv.visitInsn(DUP);
    mv.visitInsn(ICONST_3);
    mv.visitVarInsn(ALOAD, returnValueVariableIndex);
    mv.visitInsn(AASTORE);
    int traceExitArgumentValuesVariableIndex = newLocal(Type.getType("Ljava/lang/Object;"));
    mv.visitVarInsn(ASTORE, traceExitArgumentValuesVariableIndex);

    // traceExitMethod.invoke(null, traceExitArgumentValues);
    mv.visitVarInsn(ALOAD, traceExitMethodVariableIndex);
    mv.visitInsn(ACONST_NULL);
    mv.visitVarInsn(ALOAD, traceExitArgumentValuesVariableIndex);
    mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/reflect/Method", "invoke",
            "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;", false);
    mv.visitInsn(POP);

    if (theOpcode != RETURN) {// restore return value on stack only if it's not void
        mv.visitVarInsn(ALOAD, returnValueVariableIndex);

        if (isReturnValueBoxed)
            unbox(Type.getReturnType(methodDesc));
    }

    // RETURN/ARETURN/... or whatever
    mv.visitInsn(theOpcode);

    Label methodExitEnd = new Label();
    mv.visitLabel(methodExitEnd); // normal (non-exceptional) case ends here

    // exception block starts here
    int exceptionVariableIndex = newLocal(Type.getType("[Ljava/lang/Throwable;"));
    Label methodExitCatchBlock = new Label();
    mv.visitLabel(methodExitCatchBlock);
    mv.visitVarInsn(ASTORE, exceptionVariableIndex);
    Label methodExitCatchStart = new Label();
    Label methodExitCatchEnd = new Label();
    mv.visitLabel(methodExitCatchStart);
    mv.visitLabel(methodExitCatchEnd);

    if (theOpcode != RETURN) {// restore return value on stack only if it's not void
        mv.visitVarInsn(ALOAD, returnValueVariableIndex);

        if (isReturnValueBoxed)
            unbox(Type.getReturnType(methodDesc));
    }

    Label methodExitEndUltimate = new Label();
    mv.visitLabel(methodExitEndUltimate);

    // RETURN/ARETURN/... or whatever will be added by ASM (we are in the onMethodExit)

    mv.visitTryCatchBlock(methodExitStart, methodExitEnd, methodExitCatchBlock, "java/lang/Throwable");
    mv.visitLocalVariable("rv", "Ljava/lang/Object;", null, methodExitEarlyStart, methodExitEndUltimate,
            returnValueVariableIndex);
    mv.visitLocalVariable("traceExitArgumentTypes", "[Ljava/lang/Class;", null, methodExitStart, methodExitEnd,
            traceExitArgumentTypesVariableIndex);
    mv.visitLocalVariable("traceExitMethod", "Ljava/lang/reflect/Method;", null, methodExitStart, methodExitEnd,
            traceExitMethodVariableIndex);
    mv.visitLocalVariable("traceExitArgumentValues", "[Ljava/lang/Object;", null, methodExitStart,
            methodExitEnd, traceExitArgumentValuesVariableIndex);
    mv.visitLocalVariable("e", "Ljava/lang/Throwable;", null, methodExitCatchStart, methodExitCatchEnd,
            exceptionVariableIndex);
}