proguard.classfile.instruction.Instruction Maven / Gradle / Ivy
/*
* ProGuard -- shrinking, optimization, obfuscation, and preverification
* of Java bytecode.
*
* Copyright (c) 2002-2018 GuardSquare NV
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package proguard.classfile.instruction;
import proguard.classfile.*;
import proguard.classfile.attribute.CodeAttribute;
import proguard.classfile.instruction.visitor.InstructionVisitor;
/**
* Base class for representing instructions.
*
* @author Eric Lafortune
*/
public abstract class Instruction
{
// An array for marking instructions that may throw exceptions.
private static final boolean[] MAY_THROW_EXCEPTIONS = new boolean[]
{
false, // nop
false, // aconst_null
false, // iconst_m1
false, // iconst_0
false, // iconst_1
false, // iconst_2
false, // iconst_3
false, // iconst_4
false, // iconst_5
false, // lconst_0
false, // lconst_1
false, // fconst_0
false, // fconst_1
false, // fconst_2
false, // dconst_0
false, // dconst_1
false, // bipush
false, // sipush
false, // ldc
false, // ldc_w
false, // ldc2_w
false, // iload
false, // lload
false, // fload
false, // dload
false, // aload
false, // iload_0
false, // iload_1
false, // iload_2
false, // iload_3
false, // lload_0
false, // lload_1
false, // lload_2
false, // lload_3
false, // fload_0
false, // fload_1
false, // fload_2
false, // fload_3
false, // dload_0
false, // dload_1
false, // dload_2
false, // dload_3
false, // aload_0
false, // aload_1
false, // aload_2
false, // aload_3
true, // iaload
true, // laload
true, // faload
true, // daload
true, // aaload
true, // baload
true, // caload
true, // saload
false, // istore
false, // lstore
false, // fstore
false, // dstore
false, // astore
false, // istore_0
false, // istore_1
false, // istore_2
false, // istore_3
false, // lstore_0
false, // lstore_1
false, // lstore_2
false, // lstore_3
false, // fstore_0
false, // fstore_1
false, // fstore_2
false, // fstore_3
false, // dstore_0
false, // dstore_1
false, // dstore_2
false, // dstore_3
false, // astore_0
false, // astore_1
false, // astore_2
false, // astore_3
true, // iastore
true, // lastore
true, // fastore
true, // dastore
true, // aastore
true, // bastore
true, // castore
true, // sastore
false, // pop
false, // pop2
false, // dup
false, // dup_x1
false, // dup_x2
false, // dup2
false, // dup2_x1
false, // dup2_x2
false, // swap
false, // iadd
false, // ladd
false, // fadd
false, // dadd
false, // isub
false, // lsub
false, // fsub
false, // dsub
false, // imul
false, // lmul
false, // fmul
false, // dmul
true, // idiv
true, // ldiv
false, // fdiv
false, // ddiv
true, // irem
true, // lrem
false, // frem
false, // drem
false, // ineg
false, // lneg
false, // fneg
false, // dneg
false, // ishl
false, // lshl
false, // ishr
false, // lshr
false, // iushr
false, // lushr
false, // iand
false, // land
false, // ior
false, // lor
false, // ixor
false, // lxor
false, // iinc
false, // i2l
false, // i2f
false, // i2d
false, // l2i
false, // l2f
false, // l2d
false, // f2i
false, // f2l
false, // f2d
false, // d2i
false, // d2l
false, // d2f
false, // i2b
false, // i2c
false, // i2s
false, // lcmp
false, // fcmpl
false, // fcmpg
false, // dcmpl
false, // dcmpg
false, // ifeq
false, // ifne
false, // iflt
false, // ifge
false, // ifgt
false, // ifle
false, // ificmpeq
false, // ificmpne
false, // ificmplt
false, // ificmpge
false, // ificmpgt
false, // ificmple
false, // ifacmpeq
false, // ifacmpne
false, // goto
false, // jsr
false, // ret
false, // tableswitch
false, // lookupswitch
false, // ireturn
false, // lreturn
false, // freturn
false, // dreturn
false, // areturn
false, // return
true, // getstatic
true, // putstatic
true, // getfield
true, // putfield
true, // invokevirtual
true, // invokespecial
true, // invokestatic
true, // invokeinterface
true, // invokedynamic
true, // new
true, // newarray
true, // anewarray
true, // arraylength
true, // athrow
true, // checkcast
false, // instanceof
true, // monitorenter
true, // monitorexit
false, // wide
true, // multianewarray
false, // ifnull
false, // ifnonnull
false, // goto_w
false, // jsr_w
};
// An array for marking Category 2 instructions.
private static final boolean[] IS_CATEGORY2 = new boolean[]
{
false, // nop
false, // aconst_null
false, // iconst_m1
false, // iconst_0
false, // iconst_1
false, // iconst_2
false, // iconst_3
false, // iconst_4
false, // iconst_5
true, // lconst_0
true, // lconst_1
false, // fconst_0
false, // fconst_1
false, // fconst_2
true, // dconst_0
true, // dconst_1
false, // bipush
false, // sipush
false, // ldc
false, // ldc_w
true, // ldc2_w
false, // iload
true, // lload
false, // fload
true, // dload
false, // aload
false, // iload_0
false, // iload_1
false, // iload_2
false, // iload_3
true, // lload_0
true, // lload_1
true, // lload_2
true, // lload_3
false, // fload_0
false, // fload_1
false, // fload_2
false, // fload_3
true, // dload_0
true, // dload_1
true, // dload_2
true, // dload_3
false, // aload_0
false, // aload_1
false, // aload_2
false, // aload_3
false, // iaload
true, // laload
false, // faload
true, // daload
false, // aaload
false, // baload
false, // caload
false, // saload
false, // istore
true, // lstore
false, // fstore
true, // dstore
false, // astore
false, // istore_0
false, // istore_1
false, // istore_2
false, // istore_3
true, // lstore_0
true, // lstore_1
true, // lstore_2
true, // lstore_3
false, // fstore_0
false, // fstore_1
false, // fstore_2
false, // fstore_3
true, // dstore_0
true, // dstore_1
true, // dstore_2
true, // dstore_3
false, // astore_0
false, // astore_1
false, // astore_2
false, // astore_3
false, // iastore
true, // lastore
false, // fastore
true, // dastore
false, // aastore
false, // bastore
false, // castore
false, // sastore
false, // pop
true, // pop2
false, // dup
false, // dup_x1
false, // dup_x2
true, // dup2
true, // dup2_x1
true, // dup2_x2
false, // swap
false, // iadd
true, // ladd
false, // fadd
true, // dadd
false, // isub
true, // lsub
false, // fsub
true, // dsub
false, // imul
true, // lmul
false, // fmul
true, // dmul
false, // idiv
true, // ldiv
false, // fdiv
true, // ddiv
false, // irem
true, // lrem
false, // frem
true, // drem
false, // ineg
true, // lneg
false, // fneg
true, // dneg
false, // ishl
true, // lshl
false, // ishr
true, // lshr
false, // iushr
true, // lushr
false, // iand
true, // land
false, // ior
true, // lor
false, // ixor
true, // lxor
false, // iinc
false, // i2l
false, // i2f
false, // i2d
true, // l2i
true, // l2f
true, // l2d
false, // f2i
false, // f2l
false, // f2d
true, // d2i
true, // d2l
true, // d2f
false, // i2b
false, // i2c
false, // i2s
true, // lcmp
false, // fcmpl
false, // fcmpg
true, // dcmpl
true, // dcmpg
false, // ifeq
false, // ifne
false, // iflt
false, // ifge
false, // ifgt
false, // ifle
false, // ificmpeq
false, // ificmpne
false, // ificmplt
false, // ificmpge
false, // ificmpgt
false, // ificmple
false, // ifacmpeq
false, // ifacmpne
false, // goto
false, // jsr
false, // ret
false, // tableswitch
false, // lookupswitch
false, // ireturn
true, // lreturn
false, // freturn
true, // dreturn
false, // areturn
false, // return
false, // getstatic
false, // putstatic
false, // getfield
false, // putfield
false, // invokevirtual
false, // invokespecial
false, // invokestatic
false, // invokeinterface
false, // invokedynamic
false, // new
false, // newarray
false, // anewarray
false, // arraylength
false, // athrow
false, // checkcast
false, // instanceof
false, // monitorenter
false, // monitorexit
false, // wide
false, // multianewarray
false, // ifnull
false, // ifnonnull
false, // goto_w
false, // jsr_w
};
// An array containing the fixed number of entries popped from the stack,
// for all instructions.
private static final int[] STACK_POP_COUNTS = new int[]
{
0, // nop
0, // aconst_null
0, // iconst_m1
0, // iconst_0
0, // iconst_1
0, // iconst_2
0, // iconst_3
0, // iconst_4
0, // iconst_5
0, // lconst_0
0, // lconst_1
0, // fconst_0
0, // fconst_1
0, // fconst_2
0, // dconst_0
0, // dconst_1
0, // bipush
0, // sipush
0, // ldc
0, // ldc_w
0, // ldc2_w
0, // iload
0, // lload
0, // fload
0, // dload
0, // aload
0, // iload_0
0, // iload_1
0, // iload_2
0, // iload_3
0, // lload_0
0, // lload_1
0, // lload_2
0, // lload_3
0, // fload_0
0, // fload_1
0, // fload_2
0, // fload_3
0, // dload_0
0, // dload_1
0, // dload_2
0, // dload_3
0, // aload_0
0, // aload_1
0, // aload_2
0, // aload_3
2, // iaload
2, // laload
2, // faload
2, // daload
2, // aaload
2, // baload
2, // caload
2, // saload
1, // istore
2, // lstore
1, // fstore
2, // dstore
1, // astore
1, // istore_0
1, // istore_1
1, // istore_2
1, // istore_3
2, // lstore_0
2, // lstore_1
2, // lstore_2
2, // lstore_3
1, // fstore_0
1, // fstore_1
1, // fstore_2
1, // fstore_3
2, // dstore_0
2, // dstore_1
2, // dstore_2
2, // dstore_3
1, // astore_0
1, // astore_1
1, // astore_2
1, // astore_3
3, // iastore
4, // lastore
3, // fastore
4, // dastore
3, // aastore
3, // bastore
3, // castore
3, // sastore
1, // pop
2, // pop2
1, // dup
2, // dup_x1
3, // dup_x2
2, // dup2
3, // dup2_x1
4, // dup2_x2
2, // swap
2, // iadd
4, // ladd
2, // fadd
4, // dadd
2, // isub
4, // lsub
2, // fsub
4, // dsub
2, // imul
4, // lmul
2, // fmul
4, // dmul
2, // idiv
4, // ldiv
2, // fdiv
4, // ddiv
2, // irem
4, // lrem
2, // frem
4, // drem
1, // ineg
2, // lneg
1, // fneg
2, // dneg
2, // ishl
3, // lshl
2, // ishr
3, // lshr
2, // iushr
3, // lushr
2, // iand
4, // land
2, // ior
4, // lor
2, // ixor
4, // lxor
0, // iinc
1, // i2l
1, // i2f
1, // i2d
2, // l2i
2, // l2f
2, // l2d
1, // f2i
1, // f2l
1, // f2d
2, // d2i
2, // d2l
2, // d2f
1, // i2b
1, // i2c
1, // i2s
4, // lcmp
2, // fcmpl
2, // fcmpg
4, // dcmpl
4, // dcmpg
1, // ifeq
1, // ifne
1, // iflt
1, // ifge
1, // ifgt
1, // ifle
2, // ificmpeq
2, // ificmpne
2, // ificmplt
2, // ificmpge
2, // ificmpgt
2, // ificmple
2, // ifacmpeq
2, // ifacmpne
0, // goto
0, // jsr
0, // ret
1, // tableswitch
1, // lookupswitch
1, // ireturn
2, // lreturn
1, // freturn
2, // dreturn
1, // areturn
0, // return
0, // getstatic
0, // putstatic
1, // getfield
1, // putfield
1, // invokevirtual
1, // invokespecial
0, // invokestatic
1, // invokeinterface
0, // invokedynamic
0, // new
1, // newarray
1, // anewarray
1, // arraylength
1, // athrow
1, // checkcast
1, // instanceof
1, // monitorenter
1, // monitorexit
0, // wide
0, // multianewarray
1, // ifnull
1, // ifnonnull
0, // goto_w
0, // jsr_w
};
// An array containing the fixed number of entries pushed onto the stack,
// for all instructions.
private static final int[] STACK_PUSH_COUNTS = new int[]
{
0, // nop
1, // aconst_null
1, // iconst_m1
1, // iconst_0
1, // iconst_1
1, // iconst_2
1, // iconst_3
1, // iconst_4
1, // iconst_5
2, // lconst_0
2, // lconst_1
1, // fconst_0
1, // fconst_1
1, // fconst_2
2, // dconst_0
2, // dconst_1
1, // bipush
1, // sipush
1, // ldc
1, // ldc_w
2, // ldc2_w
1, // iload
2, // lload
1, // fload
2, // dload
1, // aload
1, // iload_0
1, // iload_1
1, // iload_2
1, // iload_3
2, // lload_0
2, // lload_1
2, // lload_2
2, // lload_3
1, // fload_0
1, // fload_1
1, // fload_2
1, // fload_3
2, // dload_0
2, // dload_1
2, // dload_2
2, // dload_3
1, // aload_0
1, // aload_1
1, // aload_2
1, // aload_3
1, // iaload
2, // laload
1, // faload
2, // daload
1, // aaload
1, // baload
1, // caload
1, // saload
0, // istore
0, // lstore
0, // fstore
0, // dstore
0, // astore
0, // istore_0
0, // istore_1
0, // istore_2
0, // istore_3
0, // lstore_0
0, // lstore_1
0, // lstore_2
0, // lstore_3
0, // fstore_0
0, // fstore_1
0, // fstore_2
0, // fstore_3
0, // dstore_0
0, // dstore_1
0, // dstore_2
0, // dstore_3
0, // astore_0
0, // astore_1
0, // astore_2
0, // astore_3
0, // iastore
0, // lastore
0, // fastore
0, // dastore
0, // aastore
0, // bastore
0, // castore
0, // sastore
0, // pop
0, // pop2
2, // dup
3, // dup_x1
4, // dup_x2
4, // dup2
5, // dup2_x1
6, // dup2_x2
2, // swap
1, // iadd
2, // ladd
1, // fadd
2, // dadd
1, // isub
2, // lsub
1, // fsub
2, // dsub
1, // imul
2, // lmul
1, // fmul
2, // dmul
1, // idiv
2, // ldiv
1, // fdiv
2, // ddiv
1, // irem
2, // lrem
1, // frem
2, // drem
1, // ineg
2, // lneg
1, // fneg
2, // dneg
1, // ishl
2, // lshl
1, // ishr
2, // lshr
1, // iushr
2, // lushr
1, // iand
2, // land
1, // ior
2, // lor
1, // ixor
2, // lxor
0, // iinc
2, // i2l
1, // i2f
2, // i2d
1, // l2i
1, // l2f
2, // l2d
1, // f2i
2, // f2l
2, // f2d
1, // d2i
2, // d2l
1, // d2f
1, // i2b
1, // i2c
1, // i2s
1, // lcmp
1, // fcmpl
1, // fcmpg
1, // dcmpl
1, // dcmpg
0, // ifeq
0, // ifne
0, // iflt
0, // ifge
0, // ifgt
0, // ifle
0, // ificmpeq
0, // ificmpne
0, // ificmplt
0, // ificmpge
0, // ificmpgt
0, // ificmple
0, // ifacmpeq
0, // ifacmpne
0, // goto
1, // jsr
0, // ret
0, // tableswitch
0, // lookupswitch
0, // ireturn
0, // lreturn
0, // freturn
0, // dreturn
0, // areturn
0, // return
0, // getstatic
0, // putstatic
0, // getfield
0, // putfield
0, // invokevirtual
0, // invokespecial
0, // invokestatic
0, // invokeinterface
0, // invokedynamic
1, // new
1, // newarray
1, // anewarray
1, // arraylength
0, // athrow
1, // checkcast
1, // instanceof
0, // monitorenter
0, // monitorexit
0, // wide
1, // multianewarray
0, // ifnull
0, // ifnonnull
0, // goto_w
1, // jsr_w
};
public byte opcode;
/**
* Returns the canonical opcode of this instruction, i.e. typically the
* opcode whose extension has been removed.
*/
public byte canonicalOpcode()
{
return opcode;
}
/**
* Shrinks this instruction to its shortest possible form.
* @return this instruction.
*/
public abstract Instruction shrink();
/**
* Writes the Instruction at the given offset in the given code attribute.
*/
public final void write(CodeAttribute codeAttribute, int offset)
{
write(codeAttribute.code, offset);
}
/**
* Writes the Instruction at the given offset in the given code array.
*/
public void write(byte[] code, int offset)
{
// Write the wide opcode, if necessary.
if (isWide())
{
code[offset++] = InstructionConstants.OP_WIDE;
}
// Write the opcode.
code[offset++] = opcode;
// Write any additional arguments.
writeInfo(code, offset);
}
/**
* Returns whether the instruction is wide, i.e. preceded by a wide opcode.
* With the current specifications, only variable instructions can be wide.
*/
protected boolean isWide()
{
return false;
}
/**
* Reads the data following the instruction opcode.
*/
protected abstract void readInfo(byte[] code, int offset);
/**
* Writes data following the instruction opcode.
*/
protected abstract void writeInfo(byte[] code, int offset);
/**
* Returns the length in bytes of the instruction.
*/
public abstract int length(int offset);
/**
* Accepts the given visitor.
*/
public abstract void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor);
/**
* Returns a description of the instruction, at the given offset.
*/
public String toString(int offset)
{
return "["+offset+"] "+ this.toString();
}
/**
* Returns the name of the instruction.
*/
public String getName()
{
return InstructionConstants.NAMES[opcode & 0xff];
}
/**
* Returns whether the instruction may throw exceptions.
*/
public boolean mayThrowExceptions()
{
return MAY_THROW_EXCEPTIONS[opcode & 0xff];
}
/**
* Returns whether the instruction is a Category 2 instruction. This means
* that it operates on long or double arguments.
*/
public boolean isCategory2()
{
return IS_CATEGORY2[opcode & 0xff];
}
/**
* Returns the number of entries popped from the stack during the execution
* of the instruction.
*/
public int stackPopCount(Clazz clazz)
{
return STACK_POP_COUNTS[opcode & 0xff];
}
/**
* Returns the number of entries pushed onto the stack during the execution
* of the instruction.
*/
public int stackPushCount(Clazz clazz)
{
return STACK_PUSH_COUNTS[opcode & 0xff];
}
// Small utility methods.
protected static int readByte(byte[] code, int offset)
{
return code[offset] & 0xff;
}
protected static int readShort(byte[] code, int offset)
{
return ((code[offset++] & 0xff) << 8) |
( code[offset ] & 0xff );
}
protected static int readInt(byte[] code, int offset)
{
return ( code[offset++] << 24) |
((code[offset++] & 0xff) << 16) |
((code[offset++] & 0xff) << 8) |
( code[offset ] & 0xff );
}
protected static int readValue(byte[] code, int offset, int valueSize)
{
switch (valueSize)
{
case 0: return 0;
case 1: return readByte( code, offset);
case 2: return readShort(code, offset);
case 4: return readInt( code, offset);
default: throw new IllegalArgumentException("Unsupported value size ["+valueSize+"]");
}
}
protected static int readSignedByte(byte[] code, int offset)
{
return code[offset];
}
protected static int readSignedShort(byte[] code, int offset)
{
return (code[offset++] << 8) |
(code[offset ] & 0xff);
}
protected static int readSignedValue(byte[] code, int offset, int valueSize)
{
switch (valueSize)
{
case 0: return 0;
case 1: return readSignedByte( code, offset);
case 2: return readSignedShort(code, offset);
case 4: return readInt( code, offset);
default: throw new IllegalArgumentException("Unsupported value size ["+valueSize+"]");
}
}
protected static void writeByte(byte[] code, int offset, int value)
{
if (value > 0xff)
{
throw new IllegalArgumentException("Unsigned byte value larger than 0xff ["+value+"]");
}
code[offset] = (byte)value;
}
protected static void writeShort(byte[] code, int offset, int value)
{
if (value > 0xffff)
{
throw new IllegalArgumentException("Unsigned short value larger than 0xffff ["+value+"]");
}
code[offset++] = (byte)(value >> 8);
code[offset ] = (byte)(value );
}
protected static void writeInt(byte[] code, int offset, int value)
{
code[offset++] = (byte)(value >> 24);
code[offset++] = (byte)(value >> 16);
code[offset++] = (byte)(value >> 8);
code[offset ] = (byte)(value );
}
protected static void writeValue(byte[] code, int offset, int value, int valueSize)
{
switch (valueSize)
{
case 0: break;
case 1: writeByte( code, offset, value); break;
case 2: writeShort(code, offset, value); break;
case 4: writeInt( code, offset, value); break;
default: throw new IllegalArgumentException("Unsupported value size ["+valueSize+"]");
}
}
protected static void writeSignedByte(byte[] code, int offset, int value)
{
if ((byte)value != value)
{
throw new IllegalArgumentException("Signed byte value out of range ["+value+"]");
}
code[offset] = (byte)value;
}
protected static void writeSignedShort(byte[] code, int offset, int value)
{
if ((short)value != value)
{
throw new IllegalArgumentException("Signed short value out of range ["+value+"]");
}
code[offset++] = (byte)(value >> 8);
code[offset ] = (byte)(value );
}
protected static void writeSignedValue(byte[] code, int offset, int value, int valueSize)
{
switch (valueSize)
{
case 0: break;
case 1: writeSignedByte( code, offset, value); break;
case 2: writeSignedShort(code, offset, value); break;
case 4: writeInt( code, offset, value); break;
default: throw new IllegalArgumentException("Unsupported value size ["+valueSize+"]");
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy