Java StackManipulation.apply方法代码示例

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
    MethodDescription instrumentedMethod) {

  checkMethodSignature(instrumentedMethod);

  try {
    StackManipulation stack = buildStack();
    StackManipulation.Size finalStackSize = stack.apply(methodVisitor, implementationContext);

    return new Size(finalStackSize.getMaximalSize(),
        instrumentedMethod.getStackSize() + 2); // 2 stack slots for a single local variable

  } catch (NoSuchMethodException | NoSuchFieldException e) {
    throw new RuntimeException(e);
  }
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    int numArgs = instrumentedMethod.getParameters().asTypeList().getStackSize();
    /**
     * Load the desired id
     * relative to the method arguments.
     * The idea here would be to load references
     * to declared variables
     */
    //references start with zero if its an instance or zero if its static
    //think of it like an implicit self in python without actually being defined
    int start = instrumentedMethod.isStatic() ? 1 : 0;
    StackManipulation arg0 = MethodVariableAccess.REFERENCE
                    .loadOffset(numArgs + start + OpCodeUtil.getAloadInstructionForReference(refId));
    StackManipulation.Size size = arg0.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Test
public void testConstantCreationModernInvisible() throws Exception {
    when(classFileVersion.isAtLeast(ClassFileVersion.JAVA_V5)).thenReturn(true);
    when(declaringType.isVisibleTo(instrumentedType)).thenReturn(false);
    StackManipulation stackManipulation = new FieldConstant(fieldDescription);
    assertThat(stackManipulation.isValid(), is(true));
    StackManipulation.Size size = stackManipulation.apply(methodVisitor, implementationContext);
    assertThat(size.getSizeImpact(), is(1));
    assertThat(size.getMaximalSize(), is(2));
    verify(methodVisitor).visitLdcInsn(BAZ);
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKESTATIC,
            Type.getInternalName(Class.class),
            "forName",
            Type.getMethodDescriptor(Type.getType(Class.class), Type.getType(String.class)),
            false);
    verify(methodVisitor).visitLdcInsn(BAR);
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKEVIRTUAL,
            "java/lang/Class",
            "getDeclaredField",
            "(Ljava/lang/String;)Ljava/lang/reflect/Field;",
            false);
    verifyNoMoreInteractions(methodVisitor);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Test
public void testClassConstantModernInvisible() throws Exception {
    when(typeDescription.isVisibleTo(instrumentedType)).thenReturn(false);
    when(classFileVersion.isAtLeast(ClassFileVersion.JAVA_V5)).thenReturn(true);
    when(typeDescription.getName()).thenReturn(FOO);
    StackManipulation stackManipulation = ClassConstant.of(typeDescription);
    assertThat(stackManipulation.isValid(), is(true));
    StackManipulation.Size size = stackManipulation.apply(methodVisitor, implementationContext);
    assertThat(size.getSizeImpact(), is(1));
    assertThat(size.getMaximalSize(), is(1));
    verify(typeDescription).getName();
    verify(typeDescription).isVisibleTo(instrumentedType);
    verify(typeDescription, times(9)).represents(any(Class.class));
    verifyNoMoreInteractions(typeDescription);
    verify(methodVisitor).visitLdcInsn(FOO);
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKESTATIC,
            Type.getInternalName(Class.class),
            "forName",
            Type.getMethodDescriptor(Type.getType(Class.class), Type.getType(String.class)),
            false);
    verifyNoMoreInteractions(methodVisitor);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Test
public void testTrivialBoxing() throws Exception {
    StackManipulation stackManipulation = PrimitiveUnboxingDelegate.forReferenceType(referenceTypeDescription)
            .assignUnboxedTo(primitiveTypeDescription, chainedAssigner, Assigner.Typing.STATIC);
    assertThat(stackManipulation.isValid(), is(true));
    StackManipulation.Size size = stackManipulation.apply(methodVisitor, implementationContext);
    assertThat(size.getSizeImpact(), is(sizeChange));
    assertThat(size.getMaximalSize(), is(interimMaximum));
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKEVIRTUAL,
            Type.getInternalName(referenceType),
            unboxingMethodName,
            unboxingMethodDescriptor,
            false);
    verify(methodVisitor).visitInsn(wideningOpcode);
    verifyNoMoreInteractions(methodVisitor);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Test
public void testBoxing() throws Exception {
    StackManipulation boxingStackManipulation = PrimitiveBoxingDelegate.forPrimitive(primitiveTypeDescription)
            .assignBoxedTo(targetType, chainedAssigner, Assigner.Typing.STATIC);
    assertThat(boxingStackManipulation.isValid(), is(true));
    StackManipulation.Size size = boxingStackManipulation.apply(methodVisitor, implementationContext);
    assertThat(size.getSizeImpact(), is(sizeChange));
    assertThat(size.getMaximalSize(), is(0));
    verify(primitiveTypeDescription).represents(primitiveType);
    verify(primitiveTypeDescription, atLeast(1)).represents(any(Class.class));
    verifyNoMoreInteractions(primitiveTypeDescription);
    verify(chainedAssigner).assign(referenceTypeDescription.asGenericType(), targetType, Assigner.Typing.STATIC);
    verifyNoMoreInteractions(chainedAssigner);
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKESTATIC,
            referenceTypeDescription.getInternalName(),
            VALUE_OF,
            boxingMethodDescriptor,
            false);
    verifyNoMoreInteractions(methodVisitor);
    verify(stackManipulation, atLeast(1)).isValid();
    verify(stackManipulation).apply(methodVisitor, implementationContext);
    verifyNoMoreInteractions(stackManipulation);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
/**
 * Ctor.
 * 
 * @param sm Stack manipulation to assert on.
 * @param sm2 Stack manipulation to compare with
 */
public AssertStackManipulationsAreSame(StackManipulation sm, StackManipulation sm2) {
    super(
        sm,
        mv -> {
            Implementation.Context ctx = EasyMock.mock(Implementation.Context.class);
            sm2.apply(mv, ctx);
        }
    );
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //initialize the stack with the array access with this as reference 0 and the array (first argument) as reference 1
    StackManipulation compound = assignOperation();
    StackManipulation.Size size = compound.apply(methodVisitor, implementationContext);
    //resolve the opType to store in the array and retrieve the load command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).load();
    size = size.aggregate(store.apply(methodVisitor, implementationContext));
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).load();
    StackManipulation.Size size = store.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).store();
    StackManipulation.Size size = store.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //initialize the stack with the array access with this as reference 0 and the array (first argument) as reference 1
    StackManipulation compound = assignOperation();
    StackManipulation.Size size = compound.apply(methodVisitor, implementationContext);
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).store();
    size = size.aggregate(store.apply(methodVisitor, implementationContext));
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //initialize the stack with the array access with this as reference 0 and the array (first argument) as reference 1
    StackManipulation compound = assignOperation();
    StackManipulation.Size size = compound.apply(methodVisitor, implementationContext);
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).store();
    size = size.aggregate(store.apply(methodVisitor, implementationContext));
    //set the return opType (ALWAYS REMEMBER TO DO THIS)
    StackManipulation returnOp = MethodReturn.VOID;
    size = size.aggregate(returnOp.apply(methodVisitor, implementationContext));
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //references start with zero if its an instance or zero if its static
    //think of it like an implicit self in python without actually being defined
    StackManipulation arg0 = MethodVariableAccess.REFERENCE.loadOffset(refId);
    StackManipulation.Size size = arg0.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //references start with zero if its an instance or zero if its static
    //think of it like an implicit self in python without actually being defined
    StackManipulation arg0 = MethodVariableAccess.INTEGER.loadOffset(refId);
    StackManipulation.Size size = arg0.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入方法依赖的package包/类
@Test
public void testBiPush() throws Exception {
    StackManipulation doubleConstant = DoubleConstant.forValue(value);
    assertThat(doubleConstant.isValid(), is(true));
    StackManipulation.Size size = doubleConstant.apply(methodVisitor, implementationContext);
    assertThat(size.getSizeImpact(), is(2));
    assertThat(size.getMaximalSize(), is(2));
    verify(methodVisitor).visitLdcInsn(value);
    verifyNoMoreInteractions(methodVisitor);
    verifyZeroInteractions(implementationContext);
}