You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
388 lines
15 KiB
388 lines
15 KiB
/* Opcodes Copyright (C) 1999-2002 Jochen Hoenicke.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation; either version 2, 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 Lesser General Public License
|
|
* along with this program; see the file COPYING.LESSER. If not, write to
|
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
package jode.decompiler;
|
|
import jode.type.Type;
|
|
import jode.type.IntegerType;
|
|
import jode.type.MethodType;
|
|
import jode.expr.*;
|
|
import jode.flow.*;
|
|
import jode.bytecode.*;
|
|
import java.io.*;
|
|
import java.util.Vector;
|
|
|
|
/**
|
|
* This is an abstract class which creates flow blocks for the
|
|
* opcodes in a byte stream.
|
|
*/
|
|
public abstract class Opcodes implements jode.bytecode.Opcodes {
|
|
|
|
private final static Type tIntHint
|
|
= new IntegerType(IntegerType.IT_I,
|
|
IntegerType.IT_I
|
|
| IntegerType.IT_B
|
|
| IntegerType.IT_C
|
|
| IntegerType.IT_S);
|
|
private final static Type tBoolIntHint
|
|
= new IntegerType(IntegerType.IT_I
|
|
| IntegerType.IT_Z,
|
|
IntegerType.IT_I
|
|
| IntegerType.IT_B
|
|
| IntegerType.IT_C
|
|
| IntegerType.IT_S
|
|
| IntegerType.IT_Z);
|
|
|
|
private final static int LOCAL_TYPES = 0;
|
|
private final static int ARRAY_TYPES = 1;
|
|
private final static int UNARY_TYPES = 2;
|
|
private final static int I2BCS_TYPES = 3;
|
|
private final static int BIN_TYPES = 4;
|
|
private final static int ZBIN_TYPES = 5;
|
|
|
|
private final static Type types[][] = {
|
|
// Local types
|
|
{ Type.tBoolUInt, Type.tLong, Type.tFloat, Type.tDouble,
|
|
Type.tUObject },
|
|
// Array types
|
|
{ Type.tInt, Type.tLong, Type.tFloat, Type.tDouble, Type.tUObject,
|
|
Type.tBoolByte, Type.tChar, Type.tShort },
|
|
// ifld2ifld and shl types
|
|
{ Type.tInt, Type.tLong, Type.tFloat, Type.tDouble, Type.tUObject },
|
|
// i2bcs types
|
|
{ Type.tByte, Type.tChar, Type.tShort },
|
|
// cmp/add/sub/mul/div types
|
|
{ tIntHint, Type.tLong, Type.tFloat, Type.tDouble, Type.tUObject },
|
|
// and/or/xor types
|
|
{ tBoolIntHint, Type.tLong, Type.tFloat, Type.tDouble, Type.tUObject }
|
|
};
|
|
|
|
private static StructuredBlock createNormal(MethodAnalyzer ma,
|
|
Instruction instr,
|
|
Expression expr)
|
|
{
|
|
return new InstructionBlock(expr, new Jump(FlowBlock.NEXT_BY_ADDR));
|
|
}
|
|
|
|
private static StructuredBlock createSpecial(MethodAnalyzer ma,
|
|
Instruction instr,
|
|
int type,
|
|
int stackcount, int param)
|
|
{
|
|
return new SpecialBlock(type, stackcount, param,
|
|
new Jump(FlowBlock.NEXT_BY_ADDR));
|
|
}
|
|
|
|
private static StructuredBlock createGoto(MethodAnalyzer ma,
|
|
Instruction instr)
|
|
{
|
|
return new EmptyBlock
|
|
(new Jump((FlowBlock)instr.getSingleSucc().getTmpInfo()));
|
|
}
|
|
|
|
private static StructuredBlock createJsr(MethodAnalyzer ma,
|
|
Instruction instr)
|
|
{
|
|
return new JsrBlock
|
|
(new Jump((FlowBlock)instr.getSingleSucc().getTmpInfo()),
|
|
new Jump(FlowBlock.NEXT_BY_ADDR));
|
|
}
|
|
|
|
private static StructuredBlock createIfGoto(MethodAnalyzer ma,
|
|
Instruction instr,
|
|
Expression expr)
|
|
{
|
|
return new ConditionalBlock
|
|
(expr, new Jump((FlowBlock)instr.getSingleSucc().getTmpInfo()),
|
|
new Jump(FlowBlock.NEXT_BY_ADDR));
|
|
}
|
|
|
|
private static StructuredBlock createSwitch(MethodAnalyzer ma,
|
|
Instruction instr,
|
|
int[] cases, FlowBlock[] dests)
|
|
{
|
|
return new SwitchBlock(new NopOperator(Type.tUInt), cases, dests);
|
|
}
|
|
|
|
private static StructuredBlock createBlock(MethodAnalyzer ma,
|
|
Instruction instr,
|
|
StructuredBlock block)
|
|
{
|
|
return block;
|
|
}
|
|
|
|
private static StructuredBlock createRet(MethodAnalyzer ma,
|
|
Instruction instr,
|
|
LocalInfo local)
|
|
{
|
|
return new RetBlock(local);
|
|
}
|
|
|
|
/**
|
|
* Read an opcode out of a data input stream containing the bytecode.
|
|
* @param addr The current address.
|
|
* @param stream The stream containing the java byte code.
|
|
* @param ma The Method Analyzer
|
|
* (where further information can be get from).
|
|
* @return The FlowBlock representing this opcode
|
|
* or null if the stream is empty.
|
|
* @exception IOException if an read error occured.
|
|
* @exception ClassFormatError if an invalid opcode is detected.
|
|
*/
|
|
public static StructuredBlock readOpcode(Instruction instr,
|
|
MethodAnalyzer ma)
|
|
throws ClassFormatError
|
|
{
|
|
int opcode = instr.getOpcode();
|
|
switch (opcode) {
|
|
case opc_nop:
|
|
return createBlock(ma, instr, new EmptyBlock
|
|
(new Jump(FlowBlock.NEXT_BY_ADDR)));
|
|
case opc_ldc:
|
|
case opc_ldc2_w:
|
|
return createNormal (ma, instr,
|
|
new ConstOperator(instr.getConstant()));
|
|
|
|
case opc_iload: case opc_lload:
|
|
case opc_fload: case opc_dload: case opc_aload:
|
|
return createNormal
|
|
(ma, instr, new LocalLoadOperator
|
|
(types[LOCAL_TYPES][opcode-opc_iload], ma,
|
|
ma.getLocalInfo(instr.getAddr(), instr.getLocalSlot())));
|
|
case opc_iaload: case opc_laload:
|
|
case opc_faload: case opc_daload: case opc_aaload:
|
|
case opc_baload: case opc_caload: case opc_saload:
|
|
return createNormal
|
|
(ma, instr, new ArrayLoadOperator
|
|
(types[ARRAY_TYPES][opcode - opc_iaload]));
|
|
case opc_istore: case opc_lstore:
|
|
case opc_fstore: case opc_dstore: case opc_astore:
|
|
return createNormal
|
|
(ma, instr, new StoreInstruction
|
|
(new LocalStoreOperator
|
|
(types[LOCAL_TYPES][opcode-opc_istore],
|
|
ma.getLocalInfo(instr.getNextByAddr().getAddr(),
|
|
instr.getLocalSlot()))));
|
|
case opc_iastore: case opc_lastore:
|
|
case opc_fastore: case opc_dastore: case opc_aastore:
|
|
case opc_bastore: case opc_castore: case opc_sastore:
|
|
return createNormal
|
|
(ma, instr, new StoreInstruction
|
|
(new ArrayStoreOperator
|
|
(types[ARRAY_TYPES][opcode - opc_iastore])));
|
|
case opc_pop: case opc_pop2:
|
|
return createSpecial
|
|
(ma, instr, SpecialBlock.POP, opcode - opc_pop + 1, 0);
|
|
case opc_dup: case opc_dup_x1: case opc_dup_x2:
|
|
case opc_dup2: case opc_dup2_x1: case opc_dup2_x2:
|
|
return createSpecial
|
|
(ma, instr, SpecialBlock.DUP,
|
|
(opcode - opc_dup)/3+1, (opcode - opc_dup)%3);
|
|
case opc_swap:
|
|
return createSpecial(ma, instr, SpecialBlock.SWAP, 1, 0);
|
|
case opc_iadd: case opc_ladd: case opc_fadd: case opc_dadd:
|
|
case opc_isub: case opc_lsub: case opc_fsub: case opc_dsub:
|
|
case opc_imul: case opc_lmul: case opc_fmul: case opc_dmul:
|
|
case opc_idiv: case opc_ldiv: case opc_fdiv: case opc_ddiv:
|
|
case opc_irem: case opc_lrem: case opc_frem: case opc_drem:
|
|
return createNormal
|
|
(ma, instr, new BinaryOperator
|
|
(types[BIN_TYPES][(opcode - opc_iadd)%4],
|
|
(opcode - opc_iadd)/4+Operator.ADD_OP));
|
|
case opc_ineg: case opc_lneg: case opc_fneg: case opc_dneg:
|
|
return createNormal
|
|
(ma, instr, new UnaryOperator
|
|
(types[UNARY_TYPES][opcode - opc_ineg], Operator.NEG_OP));
|
|
case opc_ishl: case opc_lshl:
|
|
case opc_ishr: case opc_lshr:
|
|
case opc_iushr: case opc_lushr:
|
|
return createNormal
|
|
(ma, instr, new ShiftOperator
|
|
(types[UNARY_TYPES][(opcode - opc_ishl)%2],
|
|
(opcode - opc_ishl)/2 + Operator.SHIFT_OP));
|
|
case opc_iand: case opc_land:
|
|
case opc_ior : case opc_lor :
|
|
case opc_ixor: case opc_lxor:
|
|
return createNormal
|
|
(ma, instr, new BinaryOperator
|
|
(types[ZBIN_TYPES][(opcode - opc_iand)%2],
|
|
(opcode - opc_iand)/2 + Operator.AND_OP));
|
|
case opc_iinc: {
|
|
int value = instr.getIncrement();
|
|
int operation = Operator.ADD_OP;
|
|
if (value < 0) {
|
|
value = -value;
|
|
operation = Operator.SUB_OP;
|
|
}
|
|
LocalInfo li
|
|
= ma.getLocalInfo(instr.getAddr(), instr.getLocalSlot());
|
|
return createNormal
|
|
(ma, instr, new IIncOperator
|
|
(new LocalStoreOperator(Type.tInt, li),
|
|
value, operation + Operator.OPASSIGN_OP));
|
|
}
|
|
case opc_i2l: case opc_i2f: case opc_i2d:
|
|
case opc_l2i: case opc_l2f: case opc_l2d:
|
|
case opc_f2i: case opc_f2l: case opc_f2d:
|
|
case opc_d2i: case opc_d2l: case opc_d2f: {
|
|
int from = (opcode-opc_i2l)/3;
|
|
int to = (opcode-opc_i2l)%3;
|
|
if (to >= from)
|
|
to++;
|
|
return createNormal
|
|
(ma, instr, new ConvertOperator(types[UNARY_TYPES][from],
|
|
types[UNARY_TYPES][to]));
|
|
}
|
|
case opc_i2b: case opc_i2c: case opc_i2s:
|
|
return createNormal
|
|
(ma, instr, new ConvertOperator
|
|
(types[UNARY_TYPES][0], types[I2BCS_TYPES][opcode-opc_i2b]));
|
|
case opc_lcmp:
|
|
case opc_fcmpl: case opc_fcmpg:
|
|
case opc_dcmpl: case opc_dcmpg:
|
|
return createNormal
|
|
(ma, instr, new CompareToIntOperator
|
|
(types[BIN_TYPES][(opcode-(opc_lcmp-3))/2],
|
|
(opcode == opc_fcmpg || opcode == opc_dcmpg)));
|
|
case opc_ifeq: case opc_ifne:
|
|
return createIfGoto
|
|
(ma, instr,
|
|
new CompareUnaryOperator
|
|
(Type.tBoolInt, opcode - (opc_ifeq-Operator.COMPARE_OP)));
|
|
case opc_iflt: case opc_ifge: case opc_ifgt: case opc_ifle:
|
|
return createIfGoto
|
|
(ma, instr,
|
|
new CompareUnaryOperator
|
|
(Type.tInt, opcode - (opc_ifeq-Operator.COMPARE_OP)));
|
|
case opc_if_icmpeq: case opc_if_icmpne:
|
|
return createIfGoto
|
|
(ma, instr,
|
|
new CompareBinaryOperator
|
|
(tBoolIntHint, opcode - (opc_if_icmpeq-Operator.COMPARE_OP)));
|
|
case opc_if_icmplt: case opc_if_icmpge:
|
|
case opc_if_icmpgt: case opc_if_icmple:
|
|
return createIfGoto
|
|
(ma, instr,
|
|
new CompareBinaryOperator
|
|
(tIntHint, opcode - (opc_if_icmpeq-Operator.COMPARE_OP)));
|
|
case opc_if_acmpeq: case opc_if_acmpne:
|
|
return createIfGoto
|
|
(ma, instr,
|
|
new CompareBinaryOperator
|
|
(Type.tUObject,
|
|
opcode - (opc_if_acmpeq-Operator.COMPARE_OP)));
|
|
case opc_goto:
|
|
return createGoto(ma, instr);
|
|
case opc_jsr:
|
|
return createJsr(ma, instr);
|
|
case opc_ret:
|
|
return createRet
|
|
(ma, instr,
|
|
ma.getLocalInfo(instr.getAddr(), instr.getLocalSlot()));
|
|
case opc_lookupswitch: {
|
|
int[] cases = instr.getValues();
|
|
FlowBlock[] dests = new FlowBlock[instr.getSuccs().length];
|
|
for (int i=0; i < dests.length; i++)
|
|
dests[i] = (FlowBlock) instr.getSuccs()[i].getTmpInfo();
|
|
dests[cases.length] = (FlowBlock)
|
|
instr.getSuccs()[cases.length].getTmpInfo();
|
|
return createSwitch(ma, instr, cases, dests);
|
|
}
|
|
case opc_ireturn: case opc_lreturn:
|
|
case opc_freturn: case opc_dreturn: case opc_areturn: {
|
|
Type retType = Type.tSubType(ma.getReturnType());
|
|
return createBlock
|
|
(ma, instr, new ReturnBlock(new NopOperator(retType)));
|
|
}
|
|
case opc_return:
|
|
return createBlock
|
|
(ma, instr, new EmptyBlock(new Jump(FlowBlock.END_OF_METHOD)));
|
|
case opc_getstatic:
|
|
case opc_getfield: {
|
|
Reference ref = instr.getReference();
|
|
return createNormal
|
|
(ma, instr, new GetFieldOperator
|
|
(ma, opcode == opc_getstatic, ref));
|
|
}
|
|
case opc_putstatic:
|
|
case opc_putfield: {
|
|
Reference ref = instr.getReference();
|
|
return createNormal
|
|
(ma, instr, new StoreInstruction
|
|
(new PutFieldOperator(ma, opcode == opc_putstatic, ref)));
|
|
}
|
|
case opc_invokevirtual:
|
|
case opc_invokespecial:
|
|
case opc_invokestatic :
|
|
case opc_invokeinterface: {
|
|
Reference ref = instr.getReference();
|
|
int flag = (ref.getName().equals("<init>")
|
|
? InvokeOperator.CONSTRUCTOR
|
|
: opcode == opc_invokestatic ? InvokeOperator.STATIC
|
|
: opcode == opc_invokespecial ? InvokeOperator.SPECIAL
|
|
: InvokeOperator.VIRTUAL);
|
|
StructuredBlock block = createNormal
|
|
(ma, instr, new InvokeOperator(ma, flag, ref));
|
|
return block;
|
|
}
|
|
case opc_new: {
|
|
Type type = Type.tType(instr.getClazzType());
|
|
ma.useType(type);
|
|
return createNormal(ma, instr, new NewOperator(type));
|
|
}
|
|
case opc_arraylength:
|
|
return createNormal
|
|
(ma, instr, new ArrayLengthOperator());
|
|
case opc_athrow:
|
|
return createBlock
|
|
(ma, instr,
|
|
new ThrowBlock(new NopOperator(Type.tUObject)));
|
|
case opc_checkcast: {
|
|
Type type = Type.tType(instr.getClazzType());
|
|
ma.useType(type);
|
|
return createNormal
|
|
(ma, instr, new CheckCastOperator(type));
|
|
}
|
|
case opc_instanceof: {
|
|
Type type = Type.tType(instr.getClazzType());
|
|
ma.useType(type);
|
|
return createNormal
|
|
(ma, instr, new InstanceOfOperator(type));
|
|
}
|
|
case opc_monitorenter:
|
|
return createNormal(ma, instr,
|
|
new MonitorEnterOperator());
|
|
case opc_monitorexit:
|
|
return createNormal(ma, instr,
|
|
new MonitorExitOperator());
|
|
case opc_multianewarray: {
|
|
Type type = Type.tType(instr.getClazzType());
|
|
ma.useType(type);
|
|
int dimension = instr.getDimensions();
|
|
return createNormal(ma, instr,
|
|
new NewArrayOperator(type, dimension));
|
|
}
|
|
case opc_ifnull: case opc_ifnonnull:
|
|
return createIfGoto
|
|
(ma, instr, new CompareUnaryOperator
|
|
(Type.tUObject, opcode - (opc_ifnull-Operator.COMPARE_OP)));
|
|
default:
|
|
throw new jode.AssertError("Invalid opcode "+opcode);
|
|
}
|
|
}
|
|
}
|
|
|