FileDocCategorySizeDatePackage
RegOps.javaAPI DocAndroid 5.1 API12883Thu Mar 12 22:18:30 GMT 2015com.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. {@code r} is the result register, {@code x} is the first argument, {@code y} is the second argument, and {@code 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
{@code nop()}
public static final int
MOVE
{@code T: any type; r,x: T :: r = x;}
public static final int
MOVE_PARAM
{@code T: any type; r,param(x): T :: r = param(x)}
public static final int
MOVE_EXCEPTION
{@code 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
{@code T: any type; r, literal: T :: r = literal;}
public static final int
GOTO
{@code goto label}
public static final int
IF_EQ
{@code T: int or Object; x,y: T :: if (x == y) goto label}
public static final int
IF_NE
{@code T: int or Object; x,y: T :: if (x != y) goto label}
public static final int
IF_LT
{@code x,y: int :: if (x < y) goto label}
public static final int
IF_GE
{@code x,y: int :: if (x >= y) goto label}
public static final int
IF_LE
{@code x,y: int :: if (x <= y) goto label}
public static final int
IF_GT
{@code x,y: int :: if (x > y) goto label}
public static final int
SWITCH
{@code x: int :: goto table[x]}
public static final int
ADD
{@code T: any numeric type; r,x,y: T :: r = x + y}
public static final int
SUB
{@code T: any numeric type; r,x,y: T :: r = x - y}
public static final int
MUL
{@code T: any numeric type; r,x,y: T :: r = x * y}
public static final int
DIV
{@code T: any numeric type; r,x,y: T :: r = x / y}
public static final int
REM
{@code T: any numeric type; r,x,y: T :: r = x % y} (Java-style remainder)
public static final int
NEG
{@code T: any numeric type; r,x: T :: r = -x}
public static final int
AND
{@code T: any integral type; r,x,y: T :: r = x & y}
public static final int
OR
{@code T: any integral type; r,x,y: T :: r = x | y}
public static final int
XOR
{@code T: any integral type; r,x,y: T :: r = x ^ y}
public static final int
SHL
{@code T: any integral type; r,x: T; y: int :: r = x << y}
public static final int
SHR
{@code T: any integral type; r,x: T; y: int :: r = x >> y} (signed right-shift)
public static final int
USHR
{@code T: any integral type; r,x: T; y: int :: r = x >>> y} (unsigned right-shift)
public static final int
NOT
{@code T: any integral type; r,x: T :: r = ~x}
public static final int
CMPL
{@code 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
{@code 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
{@code 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
{@code r,x: int :: r = (x << 24) >> 24} (Java-style convert int to byte)
public static final int
TO_CHAR
{@code r,x: int :: r = x & 0xffff} (Java-style convert int to char)
public static final int
TO_SHORT
{@code r,x: int :: r = (x << 16) >> 16} (Java-style convert int to short)
public static final int
RETURN
{@code T: return type for the method; x: T; return x}
public static final int
ARRAY_LENGTH
{@code T: any type; r: int; x: T[]; :: r = x.length}
public static final int
THROW
{@code x: Throwable :: throw(x)}
public static final int
MONITOR_ENTER
{@code x: Object :: monitorenter(x)}
public static final int
MONITOR_EXIT
{@code x: Object :: monitorexit(x)}
public static final int
AGET
{@code T: any type; r: T; x: T[]; y: int :: r = x[y]}
public static final int
APUT
{@code T: any type; x: T; y: T[]; z: int :: x[y] = z}
public static final int
NEW_INSTANCE
{@code T: any non-array object type :: r = alloc(T)} (allocate heap space for an object)
public static final int
NEW_ARRAY
{@code T: any array type; r: T; x: int :: r = new T[x]}
public static final int
FILLED_NEW_ARRAY
{@code T: any array type; r: T; x: int; v0..vx: T :: r = new T[x] {v0, ..., vx}}
public static final int
CHECK_CAST
{@code T: any object type; x: Object :: (T) x} (can throw {@code ClassCastException})
public static final int
INSTANCE_OF
{@code T: any object type; x: Object :: x instanceof T}
public static final int
GET_FIELD
{@code T: any type; r: T; x: Object; f: instance field spec of type T :: r = x.f}
public static final int
GET_STATIC
{@code T: any type; r: T; f: static field spec of type T :: r = f}
public static final int
PUT_FIELD
{@code T: any type; x: T; y: Object; f: instance field spec of type T :: y.f = x}
public static final int
PUT_STATIC
{@code T: any type; f: static field spec of type T; x: T :: f = x}
public static final int
INVOKE_STATIC
{@code 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
{@code 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
{@code 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
{@code 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
{@code 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
{@code T0: any type; name: local variable name :: mark(name,T0)} (mark beginning or end of local variable name)
public static final int
MOVE_RESULT
{@code 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
{@code 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
{@code 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 the opcode
return
{@code 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);