/*
 * Copyright 2014 - 2020 Rafael Winterhalter
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.bytebuddy.implementation.bytecode;

import net.bytebuddy.description.type.TypeDefinition;
import net.bytebuddy.implementation.Implementation;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

Duplicates a value that is lying on top of the stack.
/** * Duplicates a value that is lying on top of the stack. */
public enum Duplication implements StackManipulation {
A duplication of no values. This corresponds a no-op instruction.
/** * A duplication of no values. This corresponds a no-op instruction. */
ZERO(StackSize.ZERO, Opcodes.NOP) { @Override public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) { return size; } @Override public StackManipulation flipOver(TypeDefinition typeDefinition) { throw new IllegalStateException("Cannot flip zero value"); } },
A duplication of a single-sized stack values.
/** * A duplication of a single-sized stack values. */
SINGLE(StackSize.SINGLE, Opcodes.DUP) { @Override public StackManipulation flipOver(TypeDefinition typeDefinition) { switch (typeDefinition.getStackSize()) { case SINGLE: return WithFlip.SINGLE_SINGLE; case DOUBLE: return WithFlip.SINGLE_DOUBLE; default: throw new IllegalArgumentException("Cannot flip: " + typeDefinition); } } },
A duplication of a double-sized stack value.
/** * A duplication of a double-sized stack value. */
DOUBLE(StackSize.DOUBLE, Opcodes.DUP2) { @Override public StackManipulation flipOver(TypeDefinition typeDefinition) { switch (typeDefinition.getStackSize()) { case SINGLE: return WithFlip.DOUBLE_SINGLE; case DOUBLE: return WithFlip.DOUBLE_DOUBLE; default: throw new IllegalArgumentException("Cannot flip: " + typeDefinition); } } };
The size representing the impact of applying the duplication onto the operand stack.
/** * The size representing the impact of applying the duplication onto the operand stack. */
protected final Size size;
The opcode that represents the manipulation.
/** * The opcode that represents the manipulation. */
private final int opcode;
Creates a new duplication.
Params:
  • stackSize – The size representing the impact of applying the duplication onto the operand stack.
  • opcode – The opcode that represents the manipulation.
/** * Creates a new duplication. * * @param stackSize The size representing the impact of applying the duplication onto the operand stack. * @param opcode The opcode that represents the manipulation. */
Duplication(StackSize stackSize, int opcode) { size = stackSize.toIncreasingSize(); this.opcode = opcode; }
Duplicates a value given its type.
Params:
  • typeDefinition – The type to be duplicated.
Returns:A stack manipulation that duplicates the given type.
/** * Duplicates a value given its type. * * @param typeDefinition The type to be duplicated. * @return A stack manipulation that duplicates the given type. */
public static Duplication of(TypeDefinition typeDefinition) { switch (typeDefinition.getStackSize()) { case SINGLE: return SINGLE; case DOUBLE: return DOUBLE; case ZERO: return ZERO; default: throw new AssertionError("Unexpected type: " + typeDefinition); } }
Creates a duplication that flips the stack's top value over the second stack element.
Params:
  • typeDefinition – The type of the second element on the operand stack.
Returns:A stack manipulation that represents such a duplication flip.
/** * Creates a duplication that flips the stack's top value over the second stack element. * * @param typeDefinition The type of the second element on the operand stack. * @return A stack manipulation that represents such a duplication flip. */
public abstract StackManipulation flipOver(TypeDefinition typeDefinition);
{@inheritDoc}
/** * {@inheritDoc} */
public boolean isValid() { return true; }
{@inheritDoc}
/** * {@inheritDoc} */
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) { methodVisitor.visitInsn(opcode); return size; }
A duplication that flips a value over the second value on the operand stack.
/** * A duplication that flips a value over the second value on the operand stack. */
protected enum WithFlip implements StackManipulation {
A flip instruction that flips a single-sized element over another single-size element.
/** * A flip instruction that flips a single-sized element over another single-size element. */
SINGLE_SINGLE(Opcodes.DUP_X1, StackSize.SINGLE),
A flip instruction that flips a double-sized element over a single-size element.
/** * A flip instruction that flips a double-sized element over a single-size element. */
SINGLE_DOUBLE(Opcodes.DUP_X2, StackSize.SINGLE),
A flip instruction that flips a single-sized element over a double-size element.
/** * A flip instruction that flips a single-sized element over a double-size element. */
DOUBLE_SINGLE(Opcodes.DUP2_X1, StackSize.DOUBLE),
A flip instruction that flips a double-sized element over another double-size element.
/** * A flip instruction that flips a double-sized element over another double-size element. */
DOUBLE_DOUBLE(Opcodes.DUP2_X2, StackSize.DOUBLE);
The opcode to apply.
/** * The opcode to apply. */
private final int opcode;
The size that is added to the operand stack.
/** * The size that is added to the operand stack. */
private final StackSize stackSize;
Creates a flip duplication.
Params:
  • opcode – The opcode to apply.
  • stackSize – The size that is added to the operand stack.
/** * Creates a flip duplication. * * @param opcode The opcode to apply. * @param stackSize The size that is added to the operand stack. */
WithFlip(int opcode, StackSize stackSize) { this.opcode = opcode; this.stackSize = stackSize; }
{@inheritDoc}
/** * {@inheritDoc} */
public boolean isValid() { return true; }
{@inheritDoc}
/** * {@inheritDoc} */
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) { methodVisitor.visitInsn(opcode); return stackSize.toIncreasingSize(); } } }