FileDocCategorySizeDatePackage
RegOps.javaAPI DocAndroid 1.5 API13343Wed May 06 22:41:02 BST 2009com.android.dx.rop.code

RegOps

public final class RegOps extends Object
All the register-based opcodes, and related utilities.

Note: Opcode descriptions use a rough pseudocode. r is the result register, x is the first argument, y is the second argument, and z is the third argument. The expression which describes the operation uses Java-ish syntax but is preceded by type indicators for each of the values.

Fields Summary
public static final int
NOP
nop()
public static final int
MOVE
T: any type; r,x: T :: r = x;
public static final int
MOVE_PARAM
T: any type; r,param(x): T :: r = param(x)
public static final int
MOVE_EXCEPTION
T: Throwable; r: T :: r = caught_exception. Note: This opcode should only ever be used in the first instruction of a block, and such blocks must be the start of an exception handler.
public static final int
CONST
T: any type; r, literal: T :: r = literal;
public static final int
GOTO
goto label
public static final int
IF_EQ
T: int or Object; x,y: T :: if (x == y) goto label
public static final int
IF_NE
T: int or Object; x,y: T :: if (x != y) goto label
public static final int
IF_LT
x,y: int :: if (x < y) goto label
public static final int
IF_GE
x,y: int :: if (x >= y) goto label
public static final int
IF_LE
x,y: int :: if (x <= y) goto label
public static final int
IF_GT
x,y: int :: if (x > y) goto label
public static final int
SWITCH
x: int :: goto table[x]
public static final int
ADD
T: any numeric type; r,x,y: T :: r = x + y
public static final int
SUB
T: any numeric type; r,x,y: T :: r = x - y
public static final int
MUL
T: any numeric type; r,x,y: T :: r = x * y
public static final int
DIV
T: any numeric type; r,x,y: T :: r = x / y
public static final int
REM
T: any numeric type; r,x,y: T :: r = x % y (Java-style remainder)
public static final int
NEG
T: any numeric type; r,x: T :: r = -x
public static final int
AND
T: any integral type; r,x,y: T :: r = x & y
public static final int
OR
T: any integral type; r,x,y: T :: r = x | y
public static final int
XOR
T: any integral type; r,x,y: T :: r = x ^ y
public static final int
SHL
T: any integral type; r,x: T; y: int :: r = x << y
public static final int
SHR
T: any integral type; r,x: T; y: int :: r = x >> y (signed right-shift)
public static final int
USHR
T: any integral type; r,x: T; y: int :: r = x >>> y (unsigned right-shift)
public static final int
NOT
T: any integral type; r,x: T :: r = ~x
public static final int
CMPL
T: any numeric type; r: int; x,y: T :: r = (x == y) ? 0 : (x > y) ? 1 : -1 (Java-style "cmpl" where a NaN is considered "less than" all other values; also used for integral comparisons)
public static final int
CMPG
T: any floating point type; r: int; x,y: T :: r = (x == y) ? 0 : (x < y) ? -1 : 1 (Java-style "cmpg" where a NaN is considered "greater than" all other values)
public static final int
CONV
T: any numeric type; U: any numeric type; r: T; x: U :: r = (T) x (numeric type conversion between the four "real" numeric types)
public static final int
TO_BYTE
r,x: int :: r = (x << 24) >> 24 (Java-style convert int to byte)
public static final int
TO_CHAR
r,x: int :: r = x & 0xffff (Java-style convert int to char)
public static final int
TO_SHORT
r,x: int :: r = (x << 16) >> 16 (Java-style convert int to short)
public static final int
RETURN
T: return type for the method; x: T; return x
public static final int
ARRAY_LENGTH
T: any type; r: int; x: T[]; :: r = x.length
public static final int
THROW
x: Throwable :: throw(x)
public static final int
MONITOR_ENTER
x: Object :: monitorenter(x)
public static final int
MONITOR_EXIT
x: Object :: monitorexit(x)
public static final int
AGET
T: any type; r: T; x: T[]; y: int :: r = x[y]
public static final int
APUT
T: any type; x: T; y: T[]; z: int :: x[y] = z
public static final int
NEW_INSTANCE
T: any non-array object type :: r = alloc(T) (allocate heap space for an object)
public static final int
NEW_ARRAY
T: any array type; r: T; x: int :: r = new T[x]
public static final int
FILLED_NEW_ARRAY
T: any array type; r: T; x: int; v0..vx: T :: r = new T[x] {v0, ..., vx}
public static final int
CHECK_CAST
T: any object type; x: Object :: (T) x (can throw ClassCastException)
public static final int
INSTANCE_OF
T: any object type; x: Object :: x instanceof T
public static final int
GET_FIELD
T: any type; r: T; x: Object; f: instance field spec of type T :: r = x.f
public static final int
GET_STATIC
T: any type; r: T; f: static field spec of type T :: r = f
public static final int
PUT_FIELD
T: any type; x: T; y: Object; f: instance field spec of type T :: y.f = x
public static final int
PUT_STATIC
T: any type; f: static field spec of type T; x: T :: f = x
public static final int
INVOKE_STATIC
Tr, T0, T1...: any types; r: Tr; m: static method spec; y0: T0; y1: T1 ... :: r = m(y0, y1, ...) (call static method)
public static final int
INVOKE_VIRTUAL
Tr, T0, T1...: any types; r: Tr; x: Object; m: instance method spec; y0: T0; y1: T1 ... :: r = x.m(y0, y1, ...) (call normal virtual method)
public static final int
INVOKE_SUPER
Tr, T0, T1...: any types; r: Tr; x: Object; m: instance method spec; y0: T0; y1: T1 ... :: r = x.m(y0, y1, ...) (call superclass virtual method)
public static final int
INVOKE_DIRECT
Tr, T0, T1...: any types; r: Tr; x: Object; m: instance method spec; y0: T0; y1: T1 ... :: r = x.m(y0, y1, ...) (call direct/special method)
public static final int
INVOKE_INTERFACE
Tr, T0, T1...: any types; r: Tr; x: Object; m: interface (instance) method spec; y0: T0; y1: T1 ... :: r = x.m(y0, y1, ...) (call interface method)
public static final int
MARK_LOCAL
T0: any type; (mark beginning or end of local variable name
public static final int
MOVE_RESULT
T: Any type; r: T :: r = return_type. Note: This opcode should only ever be used in the first instruction of a block following an invoke-*.
public static final int
MOVE_RESULT_PSEUDO
T: Any type; r: T :: r = return_type. Note: This opcode should only ever be used in the first instruction of a block following a non-invoke throwing insn
public static final int
FILL_ARRAY_DATA
T: Any primitive type; v0..vx: T :: {v0, ..., vx}
Constructors Summary
private RegOps()
This class is uninstantiable.


             
      
        // This space intentionally left blank.
Methods Summary
public static intflippedIfOpcode(int opcode)
Given an IF_* RegOp, returns the right-to-left flipped version. For example, IF_GT becomes IF_LT.

param
opcode An IF_* RegOp
return
flipped IF Regop

        switch (opcode) {
            case RegOps.IF_EQ:
            case RegOps.IF_NE:
                return opcode;
            case RegOps.IF_LT:
                return RegOps.IF_GT;
            case RegOps.IF_GE:
                return RegOps.IF_LE;
            case RegOps.IF_LE:
                return RegOps.IF_GE;
            case RegOps.IF_GT:
                return RegOps.IF_LT;
            default:
                throw new RuntimeException("Unrecognized IF regop: " + opcode);
        }
public static java.lang.StringopName(int opcode)
Gets the name of the given opcode.

param
opcode >= 0, <= 255; the opcode
return
non-null; its name

        switch (opcode) {
            case NOP: return "nop";
            case MOVE: return "move";
            case MOVE_PARAM: return "move-param";
            case MOVE_EXCEPTION: return "move-exception";
            case CONST: return "const";
            case GOTO: return "goto";
            case IF_EQ: return "if-eq";
            case IF_NE: return "if-ne";
            case IF_LT: return "if-lt";
            case IF_GE: return "if-ge";
            case IF_LE: return "if-le";
            case IF_GT: return "if-gt";
            case SWITCH: return "switch";
            case ADD: return "add";
            case SUB: return "sub";
            case MUL: return "mul";
            case DIV: return "div";
            case REM: return "rem";
            case NEG: return "neg";
            case AND: return "and";
            case OR: return "or";
            case XOR: return "xor";
            case SHL: return "shl";
            case SHR: return "shr";
            case USHR: return "ushr";
            case NOT: return "not";
            case CMPL: return "cmpl";
            case CMPG: return "cmpg";
            case CONV: return "conv";
            case TO_BYTE: return "to-byte";
            case TO_CHAR: return "to-char";
            case TO_SHORT: return "to-short";
            case RETURN: return "return";
            case ARRAY_LENGTH: return "array-length";
            case THROW: return "throw";
            case MONITOR_ENTER: return "monitor-enter";
            case MONITOR_EXIT: return "monitor-exit";
            case AGET: return "aget";
            case APUT: return "aput";
            case NEW_INSTANCE: return "new-instance";
            case NEW_ARRAY: return "new-array";
            case FILLED_NEW_ARRAY: return "filled-new-array";
            case CHECK_CAST: return "check-cast";
            case INSTANCE_OF: return "instance-of";
            case GET_FIELD: return "get-field";
            case GET_STATIC: return "get-static";
            case PUT_FIELD: return "put-field";
            case PUT_STATIC: return "put-static";
            case INVOKE_STATIC: return "invoke-static";
            case INVOKE_VIRTUAL: return "invoke-virtual";
            case INVOKE_SUPER: return "invoke-super";
            case INVOKE_DIRECT: return "invoke-direct";
            case INVOKE_INTERFACE: return "invoke-interface";
            case MOVE_RESULT: return "move-result";
            case MOVE_RESULT_PSEUDO: return "move-result-pseudo";
            case FILL_ARRAY_DATA: return "fill-array-data";
        }

        return "unknown-" + Hex.u1(opcode);