import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Override
public final Result<StackManipulation> result() {
    final TypeDescription declaringType = field.getDeclaringType().asErasure();
    final TypeDescription fieldType = field.getType().asErasure();
    if(new NaturalJavaAtom().matches(fieldType)) {
        return new SmtInvokeMethod(
            new TypeDescription.ForLoadedType(Object.class),
            ElementMatchers.named("equals")
        );
    } else {
        return new SmtInvokeMethod(
            declaringType,
            new ConjunctionMatcher<>(
                ElementMatchers.isSynthetic(),
                ElementMatchers.named("atom$equal")
            )
        );
    }
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
public SmtCombinedTest() {
    super(
        new TestCase(
            "combines two StackManipulation tokens into one",
            new AssertTokenToRepresentExpectedStackManipulation(
                new SmtCombined(
                    new SmtLoadReference(5),
                    new SmtLoadReference(6)
                ),
                () -> new StackManipulation.Compound(
                    MethodVariableAccess.REFERENCE.loadFrom(5),
                    MethodVariableAccess.REFERENCE.loadFrom(6)
                )
            )
        )
    );
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Override
protected StackManipulation beforeDelegation(MethodDescription instrumentedMethod) {
  // Parameters of the wrapper invoker method:
  //   DoFnInvoker.ArgumentProvider
  // Parameters of the wrapped DoFn method:
  //   [DoFn.ProcessContext, BoundedWindow, InputProvider, OutputReceiver] in any order
  ArrayList<StackManipulation> pushParameters = new ArrayList<>();

  // To load the delegate, push `this` and then access the field
  StackManipulation pushDelegate =
      new StackManipulation.Compound(
          MethodVariableAccess.REFERENCE.loadFrom(0),
          FieldAccess.forField(delegateField).read());

  StackManipulation pushExtraContextFactory = MethodVariableAccess.REFERENCE.loadFrom(1);

  // Push the arguments in their actual order.
  for (DoFnSignature.Parameter param : signature.extraParameters()) {
    pushParameters.add(
        new StackManipulation.Compound(
            pushExtraContextFactory, getExtraContextParameter(param, pushDelegate)));
  }
  return new StackManipulation.Compound(pushParameters);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Override
protected StackManipulation beforeDelegation(MethodDescription instrumentedMethod) {
  // Parameters of the wrapper invoker method:
  //   DoFn.ArgumentProvider
  // Parameters of the wrapped DoFn method:
  //   a dynamic set of allowed "extra" parameters in any order subject to
  //   validation prior to getting the DoFnSignature
  ArrayList<StackManipulation> parameters = new ArrayList<>();

  // To load the delegate, push `this` and then access the field
  StackManipulation pushDelegate =
      new StackManipulation.Compound(
          MethodVariableAccess.REFERENCE.loadFrom(0),
          FieldAccess.forField(delegateField).read());

  StackManipulation pushExtraContextFactory = MethodVariableAccess.REFERENCE.loadFrom(1);

  // Push the extra arguments in their actual order.
  for (DoFnSignature.Parameter param : signature.extraParameters()) {
    parameters.add(
        new StackManipulation.Compound(
            pushExtraContextFactory,
            ByteBuddyDoFnInvokerFactory.getExtraContextParameter(param, pushDelegate)));
  }
  return new StackManipulation.Compound(parameters);
}
 

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包/类
/**
 * Returns the proper stack manipulation
 * for the given operation
 * @param operation the arithmetic operation to do
 * @return the stack manipulation for the given operation
 */
public static StackManipulation opFor(Operation operation) {
    switch (operation) {
        case ADD:
            return IntegerAddition.INSTANCE;
        case SUB:
            return IntegerSubtraction.INSTANCE;
        case MUL:
            return IntegerMultiplication.INSTANCE;
        case DIV:
            return IntegerDivision.INSTANCE;
        case MOD:
            return IntegerMod.INSTANCE;
        default:
            throw new IllegalArgumentException("Illegal opType of operation ");
    }
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Test
public void inPlaceSet() throws Exception {
    DynamicType.Unloaded<SetValueInPlace> val =
                    new ByteBuddy().subclass(SetValueInPlace.class)
                                    .method(ElementMatchers.isDeclaredBy(SetValueInPlace.class))
                                    .intercept(new StackManipulationImplementation(new StackManipulation.Compound(
                                                    MethodVariableAccess.REFERENCE.loadOffset(1),
                                                    MethodVariableAccess.INTEGER.loadOffset(2),
                                                    MethodVariableAccess.INTEGER.loadOffset(3),
                                                    ArrayStackManipulation.store(), MethodReturn.VOID)))
                                    .make();

    val.saveIn(new File("target"));
    SetValueInPlace dv = val.load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER).getLoaded()
                    .newInstance();
    int[] ret = {2, 4};
    int[] assertion = {1, 4};
    dv.update(ret, 0, 1);
    assertArrayEquals(assertion, ret);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Test
public void inPlaceDivide() throws Exception {
    DynamicType.Unloaded<SetValueInPlace> val = new ByteBuddy().subclass(SetValueInPlace.class)
                    .method(ElementMatchers.isDeclaredBy(SetValueInPlace.class))
                    .intercept(new StackManipulationImplementation(new StackManipulation.Compound(
                                    MethodVariableAccess.REFERENCE.loadOffset(1),
                                    MethodVariableAccess.INTEGER.loadOffset(2), Duplication.DOUBLE,
                                    ArrayStackManipulation.load(), MethodVariableAccess.INTEGER.loadOffset(3),
                                    OpStackManipulation.div(), ArrayStackManipulation.store(), MethodReturn.VOID)))
                    .make();

    val.saveIn(new File("target"));
    SetValueInPlace dv = val.load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER).getLoaded()
                    .newInstance();
    int[] ret = {2, 4};
    int[] assertion = {1, 4};
    dv.update(ret, 0, 2);
    assertArrayEquals(assertion, ret);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Test
public void testEmptyValue() throws Exception {
    when(target.getType()).thenReturn(typeDescription);
    TargetMethodAnnotationDrivenBinder.ParameterBinding<?> binding = Empty.Binder
            .INSTANCE.bind(annotationDescription,
                    source,
                    target,
                    implementationTarget,
                    assigner,
                    Assigner.Typing.STATIC);
    assertThat(binding.isValid(), is(true));
    StackManipulation.Size size = binding.apply(methodVisitor, implementationContext);
    assertThat(size.getSizeImpact(), is(typeDescription.getStackSize().getSize()));
    assertThat(size.getMaximalSize(), is(typeDescription.getStackSize().getSize()));
    verify(methodVisitor).visitInsn(opcode);
    verifyNoMoreInteractions(methodVisitor);
    verifyZeroInteractions(implementationContext);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Override
public StackManipulation apply(TypeDescription instrumentedType,
                               ByteCodeElement target,
                               TypeList.Generic arguments,
                               TypeDescription.Generic result) {
    if (!methodDescription.isAccessibleTo(instrumentedType)) {
        throw new IllegalStateException(instrumentedType + " cannot access " + methodDescription);
    }
    TypeList.Generic mapped = methodDescription.isStatic()
            ? methodDescription.getParameters().asTypeList()
            : new TypeList.Generic.Explicit(CompoundList.of(methodDescription.getDeclaringType(), methodDescription.getParameters().asTypeList()));
    if (!methodDescription.getReturnType().asErasure().isAssignableTo(result.asErasure())) {
        throw new IllegalStateException("Cannot assign return value of " + methodDescription + " to " + result);
    } else if (mapped.size() != arguments.size()) {
        throw new IllegalStateException("Cannot invoke " + methodDescription + " on " + arguments);
    }
    for (int index = 0; index < mapped.size(); index++) {
        if (!mapped.get(index).asErasure().isAssignableTo(arguments.get(index).asErasure())) {
            throw new IllegalStateException("Cannot invoke " + methodDescription + " on " + arguments);
        }
    }
    return methodDescription.isVirtual()
            ? MethodInvocation.invoke(methodDescription).virtual(target.getDeclaringType().asErasure())
            : MethodInvocation.invoke(methodDescription);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
/**
 * Applies an implementation that delegates to a invocation handler.
 *
 * @param methodVisitor         The method visitor for writing the byte code to.
 * @param implementationContext The implementation context for the current implementation.
 * @param instrumentedMethod    The method that is instrumented.
 * @param preparingManipulation A stack manipulation that applies any preparation to the operand stack.
 * @param fieldDescription      The field that contains the value for the invocation handler.
 * @return The size of the applied assignment.
 */
protected ByteCodeAppender.Size apply(MethodVisitor methodVisitor,
                                      Context implementationContext,
                                      MethodDescription instrumentedMethod,
                                      StackManipulation preparingManipulation,
                                      FieldDescription fieldDescription) {
    if (instrumentedMethod.isStatic()) {
        throw new IllegalStateException("It is not possible to apply an invocation handler onto the static method " + instrumentedMethod);
    }
    StackManipulation.Size stackSize = new StackManipulation.Compound(
            preparingManipulation,
            FieldAccess.forField(fieldDescription).read(),
            MethodVariableAccess.loadThis(),
            cacheMethods
                    ? MethodConstant.forMethod(instrumentedMethod.asDefined()).cached()
                    : MethodConstant.forMethod(instrumentedMethod.asDefined()),
            ArrayFactory.forType(TypeDescription.Generic.OBJECT).withValues(argumentValuesOf(instrumentedMethod)),
            MethodInvocation.invoke(INVOCATION_HANDLER_TYPE.getDeclaredMethods().getOnly()),
            assigner.assign(TypeDescription.Generic.OBJECT, instrumentedMethod.getReturnType(), Assigner.Typing.DYNAMIC),
            MethodReturn.of(instrumentedMethod.getReturnType())
    ).apply(methodVisitor, implementationContext);
    return new ByteCodeAppender.Size(stackSize.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static MethodDelegationBinder.ParameterBinding<?> prepareArgumentBinder(TargetMethodAnnotationDrivenBinder.ParameterBinder<?> parameterBinder,
                                                                                Class<? extends Annotation> annotationType,
                                                                                Object identificationToken) {
    doReturn(annotationType).when(parameterBinder).getHandledType();
    MethodDelegationBinder.ParameterBinding<?> parameterBinding = mock(MethodDelegationBinder.ParameterBinding.class);
    when(parameterBinding.isValid()).thenReturn(true);
    when(parameterBinding.apply(any(MethodVisitor.class), any(Implementation.Context.class))).thenReturn(new StackManipulation.Size(0, 0));
    when(parameterBinding.getIdentificationToken()).thenReturn(identificationToken);
    when(((TargetMethodAnnotationDrivenBinder.ParameterBinder) parameterBinder).bind(any(AnnotationDescription.Loadable.class),
            any(MethodDescription.class),
            any(ParameterDescription.class),
            any(Implementation.Target.class),
            any(Assigner.class),
            any(Assigner.Typing.class)))
            .thenReturn(parameterBinding);
    return parameterBinding;
}
 

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 testNonRebasedMethodIsInvokable() throws Exception {
    when(invokableMethod.getDeclaringType()).thenReturn(instrumentedType);
    when(invokableMethod.isSpecializableFor(instrumentedType)).thenReturn(true);
    when(resolution.isRebased()).thenReturn(false);
    when(resolution.getResolvedMethod()).thenReturn(invokableMethod);
    Implementation.SpecialMethodInvocation specialMethodInvocation = makeImplementationTarget().invokeSuper(rebasedSignatureToken);
    assertThat(specialMethodInvocation.isValid(), is(true));
    assertThat(specialMethodInvocation.getMethodDescription(), is((MethodDescription) invokableMethod));
    assertThat(specialMethodInvocation.getTypeDescription(), is(instrumentedType));
    MethodVisitor methodVisitor = mock(MethodVisitor.class);
    Implementation.Context implementationContext = mock(Implementation.Context.class);
    StackManipulation.Size size = specialMethodInvocation.apply(methodVisitor, implementationContext);
    verify(methodVisitor).visitMethodInsn(Opcodes.INVOKESPECIAL, BAZ, FOO, QUX, false);
    verifyNoMoreInteractions(methodVisitor);
    verifyZeroInteractions(implementationContext);
    assertThat(size.getSizeImpact(), is(0));
    assertThat(size.getMaximalSize(), is(0));
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Test
public void testExplicitTypeInitializer() throws Exception {
    assertThat(createPlain()
            .defineField(FOO, String.class, Ownership.STATIC, Visibility.PUBLIC)
            .initializer(new ByteCodeAppender() {
                @Override
                public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext, MethodDescription instrumentedMethod) {
                    return new Size(new StackManipulation.Compound(
                            new TextConstant(FOO),
                            FieldAccess.forField(instrumentedMethod.getDeclaringType().getDeclaredFields().filter(named(FOO)).getOnly()).write()
                    ).apply(methodVisitor, implementationContext).getMaximalSize(), instrumentedMethod.getStackSize());
                }
            }).make()
            .load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded()
            .getDeclaredField(FOO)
            .get(null), is((Object) FOO));
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
/**
 * Creates a new stack manipulation to load the supplied value onto the stack.
 *
 * @param value The value to serialize.
 * @return A stack manipulation to serialize the supplied value.
 */
public static StackManipulation of(Serializable value) {
    if (value == null) {
        return NullConstant.INSTANCE;
    }
    try {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        try {
            objectOutputStream.writeObject(value);
        } finally {
            objectOutputStream.close();
        }
        return new SerializedConstant(byteArrayOutputStream.toString(CHARSET));
    } catch (IOException exception) {
        throw new IllegalStateException("Cannot serialize " + value, exception);
    }
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Test
public void testConstantCreationLegacy() throws Exception {
    when(classFileVersion.isAtLeast(ClassFileVersion.JAVA_V5)).thenReturn(false);
    when(declaringType.isVisibleTo(instrumentedType)).thenReturn(true);
    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包/类
protected void testCreationUsing(Class<?> componentType, int storageOpcode) throws Exception {
    defineComponentType(componentType);
    CollectionFactory arrayFactory = ArrayFactory.forType(this.componentType);
    StackManipulation arrayStackManipulation = arrayFactory.withValues(Collections.singletonList(stackManipulation));
    assertThat(arrayStackManipulation.isValid(), is(true));
    verify(stackManipulation, atLeast(1)).isValid();
    StackManipulation.Size size = arrayStackManipulation.apply(methodVisitor, implementationContext);
    assertThat(size.getSizeImpact(), is(1));
    assertThat(size.getMaximalSize(), is(3 + StackSize.of(componentType).toIncreasingSize().getSizeImpact()));
    verify(methodVisitor).visitInsn(Opcodes.ICONST_1);
    verifyArrayCreation(methodVisitor);
    verify(methodVisitor).visitInsn(Opcodes.DUP);
    verify(methodVisitor).visitInsn(Opcodes.ICONST_0);
    verify(stackManipulation).apply(methodVisitor, implementationContext);
    verify(methodVisitor).visitInsn(storageOpcode);
    verifyNoMoreInteractions(methodVisitor);
    verifyNoMoreInteractions(stackManipulation);
}
 

import net.bytebuddy.implementation.bytecode.StackManipulation; //导入依赖的package包/类
@Test
public void testImplicitUnboxingAssignment() {
    StackManipulation stackManipulation = primitiveAssigner.assign(source, target, Assigner.Typing.DYNAMIC);
    assertThat(stackManipulation.isValid(), is(assignable));
    verify(chainedStackManipulation).isValid();
    verifyNoMoreInteractions(chainedStackManipulation);
    verify(source, atLeast(0)).represents(any(Class.class));
    verify(source, atLeast(1)).isPrimitive();
    verify(source).asGenericType();
    verifyNoMoreInteractions(source);
    verify(target, atLeast(0)).represents(any(Class.class));
    verify(target, atLeast(1)).isPrimitive();
    verifyNoMoreInteractions(target);
    verify(chainedAssigner).assign(source, new TypeDescription.Generic.OfNonGenericType.ForLoadedType(wrapperType), Assigner.Typing.DYNAMIC);
    verifyNoMoreInteractions(chainedAssigner);
}