com.nerdvision.agent.inst.asm.Visitor Maven / Gradle / Ivy

Go to download
package com.nerdvision.agent.inst.asm;

import com.google.common.collect.Sets;
import com.nerdvision.agent.api.IBreakpoint;
import java.com.nerdvision.agent.snapshot.ProxyCallback;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.LineNumberNode;
import org.objectweb.asm.tree.LocalVariableNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.TypeInsnNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.objectweb.asm.Opcodes.ALOAD;
import static org.objectweb.asm.Opcodes.ASM7;
import static org.objectweb.asm.Opcodes.ASM8;
import static org.objectweb.asm.Opcodes.DLOAD;
import static org.objectweb.asm.Opcodes.DUP;
import static org.objectweb.asm.Opcodes.FLOAD;
import static org.objectweb.asm.Opcodes.GETSTATIC;
import static org.objectweb.asm.Opcodes.ILOAD;
import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
import static org.objectweb.asm.Opcodes.INVOKESTATIC;
import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
import static org.objectweb.asm.Opcodes.LLOAD;
import static org.objectweb.asm.Opcodes.NEW;
import static org.objectweb.asm.Opcodes.POP;

public class Visitor extends ClassVisitor
{
    // these are the local variables that we want to capture when using CF, if we try to get all locals we get verify errors.
    // and we do not care about all the locals for CF.
    private static final List CF_VARS = Arrays.asList( "__localScope", "instance", "__arguments", "this", "parentPage" );
    private static final Logger LOGGER = LoggerFactory.getLogger( Visitor.class );
    private static final SkipException EXCEPTION = new SkipException();
    private static final boolean DEBUG = false;

    private final Collection bps;
    private final boolean isCf;
    private final Map> lineNos;

    private String classname;
    private String filename;

    private boolean changed = false;

    public static final Class CALLBACK_CLASS;

    static
    {
        // this is here to make the tests easier.
        // we cannot use java. classes in the tests without screwing with the class loaders
        // so in the tests we use the 'nv.callback.class' which is the CallBack.class
        // at runtime we use the ProxyCallback.class so we can bypass the osgi classloading restrictions
        final String property = System.getProperty( "nv.callback.class" );
        if( property == null )
        {
            CALLBACK_CLASS = ProxyCallback.class;
        }
        else
        {
            Class callbackClass;
            try
            {
                callbackClass = Class.forName( property );
            }
            catch( ClassNotFoundException e )
            {
                callbackClass = ProxyCallback.class;
            }
            CALLBACK_CLASS = callbackClass;
        }
    }

    public Visitor( final ClassVisitor v, final Collection bps, final boolean isCf )
    {
        super( ASM8, v );
        this.bps = bps;
        this.isCf = isCf;
        lineNos = new HashMap<>();
        for( final IBreakpoint bp : bps )
        {
            final long lineNo = bp.getLineNo();
            List list = lineNos.get( lineNo );

            if( list == null )
            {
                list = new ArrayList<>();
                lineNos.put( lineNo, list );
            }
            list.add( bp );
        }
    }


    public boolean wasChanged()
    {
        return changed;
    }


    public String getFilename()
    {
        return filename;
    }


    @Override
    public void visit( int version, int access, String name, String signature, String superName, String[] interfaces )
    {
        LOGGER.debug( "visit {}", name );
        this.classname = name;
        super.visit( version, access, name, signature, superName, interfaces );
    }


    @Override
    public void visitSource( String source, String debug )
    {
        LOGGER.debug( "visitSource {} {}", classname, source );
        super.visitSource( source, debug );

        // No source filename
        if( source == null )
        {
            throw EXCEPTION;
        }

        filename = source;
    }


    @Override
    public MethodVisitor visitMethod( int access, String name, String desc, String signature, String[] exceptions )
    {
        LOGGER.debug( "visitMethod {} {}", classname, name );
        final MethodVisitor methodVisitor = super.visitMethod( access, name, desc, signature, exceptions );

        return new MethodNode( ASM7, access, name, desc, signature, exceptions )
        {
            @Override
            public void visitEnd()
            {
                // Cannot go from line number label offset to label offset as getOffset throws.
                // java.lang.IllegalStateException: Label offset position has not been resolved yet
                // no idea why as the java local var table knows exactly at what byte code op vars are valid
                final Set seenLabels = Sets.newIdentityHashSet();

                final ListIterator it = instructions.iterator();
                while( it.hasNext() )
                {
                    AbstractInsnNode node = it.next();
                    if( node.getType() == AbstractInsnNode.LABEL )
                    {
                        LabelNode lab = (LabelNode) node;
                        seenLabels.add( lab.getLabel() );
                    }

                    if( node.getType() == AbstractInsnNode.LINE )
                    {
                        LineNumberNode ln = (LineNumberNode) node;
                        // we remove them so only the first line has the breakpoint installed. Only the first line will be hit as all subsequent will be disabled
                        final List iBreakpoints = lineNos.remove( (long) ln.line );
                        if( iBreakpoints != null )
                        {
                            LOGGER.trace( "visitMethod {} {} line number {}", classname, name, ln.line );
                            final InsnList hook = new InsnList();

                            if( DEBUG )
                            {
                                hook.add(
                                        new FieldInsnNode( GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;" ) );
                                hook.add( new LdcInsnNode( "DEBUG BREAKPOINT " + classname + "." + name + ":" + ln.line ) );
                                hook.add( new MethodInsnNode( INVOKEVIRTUAL, "java/io/PrintStream", "println",
                                        "(Ljava/lang/String;)V", false ) );

                                hook.add( new MethodInsnNode( INVOKESTATIC, Type.getInternalName( Thread.class ), "dumpStack",
                                        Type.getMethodDescriptor( Type.VOID_TYPE ), false ) );
                            }

                            hook.add( new TypeInsnNode( NEW, Type.getInternalName( ArrayList.class ) ) );
                            hook.add( new InsnNode( DUP ) );
                            hook.add( new MethodInsnNode( INVOKESPECIAL, Type.getInternalName( ArrayList.class ), "",
                                    "()V", false ) );

                            for( final IBreakpoint bp : iBreakpoints )
                            {
                                hook.add( new InsnNode( DUP ) ); // we need a ptr to our map
                                hook.add( new LdcInsnNode( bp.getId() ) ); // bp id
                                hook.add( new MethodInsnNode( INVOKEVIRTUAL, Type.getInternalName( ArrayList.class ), "add",
                                        "(Ljava/lang/Object;)Z" ) );
                                hook.add( new InsnNode( POP ) ); // dont care about return
                            }

                            // Put our location on stack for last call
                            hook.add( new LdcInsnNode( filename ) );
                            hook.add( new LdcInsnNode( ln.line ) );
                            // Make a map of locals

                            hook.add( new TypeInsnNode( NEW, Type.getInternalName( HashMap.class ) ) );
                            hook.add( new InsnNode( DUP ) );
                            hook.add( new MethodInsnNode( INVOKESPECIAL, Type.getInternalName( HashMap.class ), "",
                                    "()V", false ) );

                            // add this
                            if( !isStatic( access ) )
                            {
                                hook.add( new InsnNode( DUP ) ); // we need a ptr to our map
                                hook.add( new LdcInsnNode( "this" ) ); // key
                                hook.add( new VarInsnNode( ALOAD, 0 ) ); // value
                                // call map.put(name, value)
                                hook.add( new MethodInsnNode( INVOKEVIRTUAL, Type.getInternalName( HashMap.class ),
                                        "put",
                                        Type.getMethodDescriptor( Type.getType( Object.class ),
                                                Type.getType( Object.class ), Type.getType( Object.class ) ),
                                        false ) );
                                hook.add( new InsnNode( POP ) ); // dont care about return
                            }

                            // Have Map
                            for( LocalVariableNode l : localVariables )
                            {
                                if( !isCf || CF_VARS.contains( l.name ) )
                                {
                                    if( seenLabels.contains( l.start.getLabel() )
                                            && !seenLabels.contains( l.end.getLabel() ) )
                                    {
                                        LOGGER.debug( "visitMethod {} {} Adding variable {}", classname, name, l.name );
                                        hook.add( new InsnNode( DUP ) ); // we need a ptr to our map
                                        hook.add( new LdcInsnNode( l.name ) ); // key
                                        hook.add( loadVariable( Type.getType( l.desc ), l.index ) ); // value
                                        // call map.put(name, value)
                                        hook.add( new MethodInsnNode( INVOKEVIRTUAL, Type.getInternalName( HashMap.class ),
                                                "put",
                                                Type.getMethodDescriptor( Type.getType( Object.class ),
                                                        Type.getType( Object.class ), Type.getType( Object.class ) ),
                                                false ) );
                                        hook.add( new InsnNode( POP ) ); // dont care about return
                                    }
                                    else
                                    {
                                        LOGGER.debug( "visitMethod {} {} Skipping variable {}", classname, name, l.name );
                                    }
                                }
                            }

                            final Type[] argumentTypes = Type.getArgumentTypes( desc );
                            // if we have params but no locals (except this) then add the params
                            if( argumentTypes.length != 0 && noneOrJustThis( localVariables ) )
                            {
                                for( int i = 0; i < argumentTypes.length; i++ )
                                {
                                    final Type argumentType = argumentTypes[i];
                                    final String pramName = "param" + i;
                                    LOGGER.debug( "visitMethod {} {} Adding variable {}", classname, name, pramName );
                                    hook.add( new InsnNode( DUP ) ); // we need a ptr to our map
                                    hook.add( new LdcInsnNode( pramName ) ); // key
                                    hook.add( loadVariable( argumentType, i + 1 ) ); // value
                                    // call map.put(name, value)
                                    hook.add( new MethodInsnNode( INVOKEVIRTUAL, Type.getInternalName( HashMap.class ),
                                            "put",
                                            Type.getMethodDescriptor( Type.getType( Object.class ),
                                                    Type.getType( Object.class ), Type.getType( Object.class ) ),
                                            false ) );
                                    hook.add( new InsnNode( POP ) ); // dont care about return
                                }
                            }

                            // Call callback
                            hook.add( new MethodInsnNode( INVOKESTATIC, Type.getInternalName( CALLBACK_CLASS ),
                                    isCf ? "callBackCF" : "callBack",
                                    Type.getMethodDescriptor( Type.VOID_TYPE,
                                            Type.getType( List.class ),
                                            Type.getType( String.class ), Type.INT_TYPE, Type.getType( Map.class ) ),
                                    false ) );

                            changed = true;

                            instructions.insert( ln, hook );

                            LOGGER.debug( "visitMethod {} {} patched @ {} {}", classname, name, ln.line, bps );
                        }
                    }
                }

                this.accept( methodVisitor );

                super.visitEnd();
            }
        };
    }


    private boolean isStatic( final int access )
    {
        return (access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
    }


    private boolean noneOrJustThis( final List localVariables )
    {
        if( localVariables.isEmpty() )
        {
            return true;
        }
        if( localVariables.size() == 1 )
        {
            return localVariables.get( 0 ).name.equals( "this" );
        }
        return false;
    }


    /**
     * Generates a XXLOAD operation for a specific variable slot type.
     */
    private InsnList loadVariable( final Type t, final int index )
    {
        final int sort = t.getSort();
        switch( sort )
        {
            case Type.BYTE:
                return box( index, Type.BYTE_TYPE, Byte.class, ILOAD );
            case Type.CHAR:
                return box( index, Type.CHAR_TYPE, Character.class, ILOAD );
            case Type.DOUBLE:
                return box( index, Type.DOUBLE_TYPE, Double.class, DLOAD );
            case Type.FLOAT:
                return box( index, Type.FLOAT_TYPE, Float.class, FLOAD );
            case Type.INT:
                return box( index, Type.INT_TYPE, Integer.class, ILOAD );
            case Type.LONG:
                return box( index, Type.LONG_TYPE, Long.class, LLOAD );
            case Type.SHORT:
                return box( index, Type.SHORT_TYPE, Short.class, ILOAD );
            case Type.BOOLEAN:
                return box( index, Type.BOOLEAN_TYPE, Boolean.class, ILOAD );
            case Type.ARRAY:
            case Type.OBJECT:
                final InsnList ops = new InsnList();
                ops.add( new VarInsnNode( ALOAD, index ) );
                return ops;
            default:
                // Something is very strange
                LOGGER.error( "loadVariable - Unknown type : {}", t );
                final InsnList valueGetter = new InsnList();
                valueGetter.add( new LdcInsnNode( "Unknown type :" + t ) );
                return valueGetter;
        }
    }


    /**
     * Converts primatives to objects so we can put them in the map
     */
    private static InsnList box( final int index, final Type primitive, final Class clazz, final int loadOpcode )
    {
        final InsnList boxOperations = new InsnList();
        boxOperations.add( new VarInsnNode( loadOpcode, index ) );
        // Call Double.valueOf or Long.valueOf etc
        boxOperations.add( new MethodInsnNode( INVOKESTATIC, Type.getInternalName( clazz ), "valueOf",
                Type.getMethodDescriptor( Type.getType( clazz ), primitive ), false ) );
        return boxOperations;
    }
}