Rops (platform/dalvik dx 11.0.0

java.lang.Object
- com.android.dx.rop.code.Rops

public final class Rops
extends java.lang.Object

Standard instances of Rop.

Field Summary

Fields
Modifier and Type	Field and Description
`static Rop`	`ADD_CONST_DOUBLE` `r,x,c: double :: r = x + c;`
`static Rop`	`ADD_CONST_FLOAT` `r,x,c: float :: r = x + c;`
`static Rop`	`ADD_CONST_INT` `r,x,c: int :: r = x + c;`
`static Rop`	`ADD_CONST_LONG` `r,x,c: long :: r = x + c;`
`static Rop`	`ADD_DOUBLE` `r,x,y: double :: r = x + y;`
`static Rop`	`ADD_FLOAT` `r,x,y: float :: r = x + y;`
`static Rop`	`ADD_INT` `r,x,y: int :: r = x + y;`
`static Rop`	`ADD_LONG` `r,x,y: long :: r = x + y;`
`static Rop`	`AGET_BOOLEAN` `r: boolean; x: boolean[]; y: int :: r = x[y]`
`static Rop`	`AGET_BYTE` `r: byte; x: byte[]; y: int :: r = x[y]`
`static Rop`	`AGET_CHAR` `r: char; x: char[]; y: int :: r = x[y]`
`static Rop`	`AGET_DOUBLE` `r: double; x: double[]; y: int :: r = x[y]`
`static Rop`	`AGET_FLOAT` `r: float; x: float[]; y: int :: r = x[y]`
`static Rop`	`AGET_INT` `r,y: int; x: int[] :: r = x[y]`
`static Rop`	`AGET_LONG` `r: long; x: long[]; y: int :: r = x[y]`
`static Rop`	`AGET_OBJECT` `r: Object; x: Object[]; y: int :: r = x[y]`
`static Rop`	`AGET_SHORT` `r: short; x: short[]; y: int :: r = x[y]`
`static Rop`	`AND_CONST_INT` `r,x,c: int :: r = x & c;`
`static Rop`	`AND_CONST_LONG` `r,x,c: long :: r = x & c;`
`static Rop`	`AND_INT` `r,x,y: int :: r = x & y;`
`static Rop`	`AND_LONG` `r,x,y: long :: r = x & y;`
`static Rop`	`APUT_BOOLEAN` `x: boolean; y: boolean[]; z: int :: y[z] = x`
`static Rop`	`APUT_BYTE` `x: byte; y: byte[]; z: int :: y[z] = x`
`static Rop`	`APUT_CHAR` `x: char; y: char[]; z: int :: y[z] = x`
`static Rop`	`APUT_DOUBLE` `x: double; y: double[]; z: int :: y[z] = x`
`static Rop`	`APUT_FLOAT` `x: float; y: float[]; z: int :: y[z] = x`
`static Rop`	`APUT_INT` `x,z: int; y: int[] :: y[z] = x`
`static Rop`	`APUT_LONG` `x: long; y: long[]; z: int :: y[z] = x`
`static Rop`	`APUT_OBJECT` `x: Object; y: Object[]; z: int :: y[z] = x`
`static Rop`	`APUT_SHORT` `x: short; y: short[]; z: int :: y[z] = x`
`static Rop`	`ARRAY_LENGTH` `T: any type; r: int; x: T[]; :: r = x.length`
`static Rop`	`CHECK_CAST` `T: any non-array object type; x: Object :: (T) x` (can throw `ClassCastException`)
`static Rop`	`CMPG_DOUBLE` `r: int; x,y: double :: r = cmpg(x, y);`
`static Rop`	`CMPG_FLOAT` `r: int; x,y: float :: r = cmpg(x, y);`
`static Rop`	`CMPL_DOUBLE` `r: int; x,y: double :: r = cmpl(x, y);`
`static Rop`	`CMPL_FLOAT` `r: int; x,y: float :: r = cmpl(x, y);`
`static Rop`	`CMPL_LONG` `r: int; x,y: long :: r = cmp(x, y);`
`static Rop`	`CONST_DOUBLE` `r, literal: double :: r = literal;`
`static Rop`	`CONST_FLOAT` `r, literal: float :: r = literal;`
`static Rop`	`CONST_INT` `r, literal: int :: r = literal;`
`static Rop`	`CONST_LONG` `r, literal: long :: r = literal;`
`static Rop`	`CONST_OBJECT` `r, literal: Object :: r = literal;`
`static Rop`	`CONST_OBJECT_NOTHROW` `r, literal: Object :: r = literal;`
`static Rop`	`CONV_D2F` `r: float; x: double :: r = (float) x`
`static Rop`	`CONV_D2I` `r: int; x: double :: r = (int) x`
`static Rop`	`CONV_D2L` `r: long; x: double :: r = (long) x`
`static Rop`	`CONV_F2D` `r: double; x: float :: r = (double) x`
`static Rop`	`CONV_F2I` `r: int; x: float :: r = (int) x`
`static Rop`	`CONV_F2L` `r: long; x: float :: r = (long) x`
`static Rop`	`CONV_I2D` `r: double; x: int :: r = (double) x`
`static Rop`	`CONV_I2F` `r: float; x: int :: r = (float) x`
`static Rop`	`CONV_I2L` `r: long; x: int :: r = (long) x`
`static Rop`	`CONV_L2D` `r: double; x: long :: r = (double) x`
`static Rop`	`CONV_L2F` `r: float; x: long :: r = (float) x`
`static Rop`	`CONV_L2I` `r: int; x: long :: r = (int) x`
`static Rop`	`DIV_CONST_DOUBLE` `r,x,c: double :: r = x / c;`
`static Rop`	`DIV_CONST_FLOAT` `r,x,c: float :: r = x / c;`
`static Rop`	`DIV_CONST_INT` `r,x,c: int :: r = x / c;`
`static Rop`	`DIV_CONST_LONG` `r,x,c: long :: r = x / c;`
`static Rop`	`DIV_DOUBLE` `r,x,y: double :: r = x / y;`
`static Rop`	`DIV_FLOAT` `r,x,y: float :: r = x / y;`
`static Rop`	`DIV_INT` `r,x,y: int :: r = x / y;`
`static Rop`	`DIV_LONG` `r,x,y: long :: r = x / y;`
`static Rop`	`FILL_ARRAY_DATA` `T: Any primitive type; v0..vx: T :: {v0, ..., vx}`
`static Rop`	`GET_FIELD_BOOLEAN` `r: boolean; x: Object; f: instance field spec of type boolean :: r = x.f`
`static Rop`	`GET_FIELD_BYTE` `r: byte; x: Object; f: instance field spec of type byte :: r = x.f`
`static Rop`	`GET_FIELD_CHAR` `r: char; x: Object; f: instance field spec of type char :: r = x.f`
`static Rop`	`GET_FIELD_DOUBLE` `r: double; x: Object; f: instance field spec of type double :: r = x.f`
`static Rop`	`GET_FIELD_FLOAT` `r: float; x: Object; f: instance field spec of type float :: r = x.f`
`static Rop`	`GET_FIELD_INT` `r: int; x: Object; f: instance field spec of type int :: r = x.f`
`static Rop`	`GET_FIELD_LONG` `r: long; x: Object; f: instance field spec of type long :: r = x.f`
`static Rop`	`GET_FIELD_OBJECT` `r: Object; x: Object; f: instance field spec of type Object :: r = x.f`
`static Rop`	`GET_FIELD_SHORT` `r: short; x: Object; f: instance field spec of type short :: r = x.f`
`static Rop`	`GET_STATIC_BOOLEAN` `r: boolean; f: static field spec of type boolean :: r = f`
`static Rop`	`GET_STATIC_BYTE` `r: byte; f: static field spec of type byte :: r = f`
`static Rop`	`GET_STATIC_CHAR` `r: char; f: static field spec of type char :: r = f`
`static Rop`	`GET_STATIC_DOUBLE` `r: double; f: static field spec of type double :: r = f`
`static Rop`	`GET_STATIC_FLOAT` `r: float; f: static field spec of type float :: r = f`
`static Rop`	`GET_STATIC_INT` `r: int; f: static field spec of type int :: r = f`
`static Rop`	`GET_STATIC_LONG` `r: long; f: static field spec of type long :: r = f`
`static Rop`	`GET_STATIC_OBJECT` `r: Object; f: static field spec of type Object :: r = f`
`static Rop`	`GET_STATIC_SHORT` `r: short; f: static field spec of type short :: r = f`
`static Rop`	`GOTO` `goto label`
`static Rop`	`IF_EQ_INT` `x,y: int :: if (x == y) goto label`
`static Rop`	`IF_EQ_OBJECT` `x,y: Object :: if (x == y) goto label`
`static Rop`	`IF_EQZ_INT` `x: int :: if (x == 0) goto label`
`static Rop`	`IF_EQZ_OBJECT` `x: Object :: if (x == null) goto label`
`static Rop`	`IF_GE_INT` `x,y: int :: if (x >= y) goto label`
`static Rop`	`IF_GEZ_INT` `x: int :: if (x >= 0) goto label`
`static Rop`	`IF_GT_INT` `x,y: int :: if (x > y) goto label`
`static Rop`	`IF_GTZ_INT` `x: int :: if (x > 0) goto label`
`static Rop`	`IF_LE_INT` `x,y: int :: if (x <= y) goto label`
`static Rop`	`IF_LEZ_INT` `x: int :: if (x <= 0) goto label`
`static Rop`	`IF_LT_INT` `x,y: int :: if (x < y) goto label`
`static Rop`	`IF_LTZ_INT` `x: int :: if (x < 0) goto label`
`static Rop`	`IF_NE_INT` `x,y: int :: if (x != y) goto label`
`static Rop`	`IF_NE_OBJECT` `x,y: Object :: if (x != y) goto label`
`static Rop`	`IF_NEZ_INT` `x: int :: if (x != 0) goto label`
`static Rop`	`IF_NEZ_OBJECT` `x: Object :: if (x != null) goto label`
`static Rop`	`INSTANCE_OF` `T: any non-array object type; x: Object :: x instanceof T`.
`static Rop`	`MARK_LOCAL_DOUBLE` `x: Double :: local variable begins in x`
`static Rop`	`MARK_LOCAL_FLOAT` `x: Float :: local variable begins in x`
`static Rop`	`MARK_LOCAL_INT` `x: Int :: local variable begins in x`
`static Rop`	`MARK_LOCAL_LONG` `x: Long :: local variable begins in x`
`static Rop`	`MARK_LOCAL_OBJECT` `x: Object :: local variable begins in x`
`static Rop`	`MONITOR_ENTER` `x: Object :: monitorenter(x)`
`static Rop`	`MONITOR_EXIT` `x: Object :: monitorexit(x)`
`static Rop`	`MOVE_DOUBLE` `r,x: double :: r = x;`
`static Rop`	`MOVE_FLOAT` `r,x: float :: r = x;`
`static Rop`	`MOVE_INT` `r,x: int :: r = x;`
`static Rop`	`MOVE_LONG` `r,x: long :: r = x;`
`static Rop`	`MOVE_OBJECT` `r,x: Object :: r = x;`
`static Rop`	`MOVE_PARAM_DOUBLE` `r,param(x): double :: r = param(x);`
`static Rop`	`MOVE_PARAM_FLOAT` `r,param(x): float :: r = param(x);`
`static Rop`	`MOVE_PARAM_INT` `r,param(x): int :: r = param(x);`
`static Rop`	`MOVE_PARAM_LONG` `r,param(x): long :: r = param(x);`
`static Rop`	`MOVE_PARAM_OBJECT` `r,param(x): Object :: r = param(x);`
`static Rop`	`MOVE_RETURN_ADDRESS` `r,x: ReturnAddress :: r = x;` Note that this rop-form instruction has no dex-form equivilent and must be removed before the dex conversion.
`static Rop`	`MUL_CONST_DOUBLE` `r,x,c: double :: r = x * c;`
`static Rop`	`MUL_CONST_FLOAT` `r,x,c: float :: r = x * c;`
`static Rop`	`MUL_CONST_INT` `r,x,c: int :: r = x * c;`
`static Rop`	`MUL_CONST_LONG` `r,x,c: long :: r = x * c;`
`static Rop`	`MUL_DOUBLE` `r,x,y: double :: r = x * y;`
`static Rop`	`MUL_FLOAT` `r,x,y: float :: r = x * y;`
`static Rop`	`MUL_INT` `r,x,y: int :: r = x * y;`
`static Rop`	`MUL_LONG` `r,x,y: long :: r = x * y;`
`static Rop`	`NEG_DOUBLE` `r,x: double :: r = -x;`
`static Rop`	`NEG_FLOAT` `r,x: float :: r = -x;`
`static Rop`	`NEG_INT` `r,x: int :: r = -x;`
`static Rop`	`NEG_LONG` `r,x: long :: r = -x;`
`static Rop`	`NEW_ARRAY_BOOLEAN` `r: boolean[]; x: int :: r = new boolean[x]`
`static Rop`	`NEW_ARRAY_BYTE` `r: byte[]; x: int :: r = new byte[x]`
`static Rop`	`NEW_ARRAY_CHAR` `r: char[]; x: int :: r = new char[x]`
`static Rop`	`NEW_ARRAY_DOUBLE` `r: double[]; x: int :: r = new double[x]`
`static Rop`	`NEW_ARRAY_FLOAT` `r: float[]; x: int :: r = new float[x]`
`static Rop`	`NEW_ARRAY_INT` `r: int[]; x: int :: r = new int[x]`
`static Rop`	`NEW_ARRAY_LONG` `r: long[]; x: int :: r = new long[x]`
`static Rop`	`NEW_ARRAY_SHORT` `r: short[]; x: int :: r = new short[x]`
`static Rop`	`NEW_INSTANCE` `T: any non-array object type :: r = alloc(T)` (allocate heap space for an object)
`static Rop`	`NOP` `nop()`
`static Rop`	`NOT_INT` `r,x: int :: r = ~x;`
`static Rop`	`NOT_LONG` `r,x: long :: r = ~x;`
`static Rop`	`OR_CONST_INT` `r,x,c: int :: r = x \| c;`
`static Rop`	`OR_CONST_LONG` `r,x,c: long :: r = x \| c;`
`static Rop`	`OR_INT` `r,x,y: int :: r = x \| y;`
`static Rop`	`OR_LONG` `r,x,y: long :: r = x \| y;`
`static Rop`	`PUT_FIELD_BOOLEAN` `x: int; y: Object; f: instance field spec of type boolean :: y.f = x`
`static Rop`	`PUT_FIELD_BYTE` `x: int; y: Object; f: instance field spec of type byte :: y.f = x`
`static Rop`	`PUT_FIELD_CHAR` `x: int; y: Object; f: instance field spec of type char :: y.f = x`
`static Rop`	`PUT_FIELD_DOUBLE` `x: double; y: Object; f: instance field spec of type double :: y.f = x`
`static Rop`	`PUT_FIELD_FLOAT` `x: float; y: Object; f: instance field spec of type float :: y.f = x`
`static Rop`	`PUT_FIELD_INT` `x: int; y: Object; f: instance field spec of type int :: y.f = x`
`static Rop`	`PUT_FIELD_LONG` `x: long; y: Object; f: instance field spec of type long :: y.f = x`
`static Rop`	`PUT_FIELD_OBJECT` `x: Object; y: Object; f: instance field spec of type Object :: y.f = x`
`static Rop`	`PUT_FIELD_SHORT` `x: int; y: Object; f: instance field spec of type short :: y.f = x`
`static Rop`	`PUT_STATIC_BOOLEAN` `f: static field spec of type boolean; x: boolean :: f = x`
`static Rop`	`PUT_STATIC_BYTE` `f: static field spec of type byte; x: byte :: f = x`
`static Rop`	`PUT_STATIC_CHAR` `f: static field spec of type char; x: char :: f = x`
`static Rop`	`PUT_STATIC_DOUBLE` `f: static field spec of type double; x: double :: f = x`
`static Rop`	`PUT_STATIC_FLOAT` `f: static field spec of type float; x: float :: f = x`
`static Rop`	`PUT_STATIC_INT` `f: static field spec of type int; x: int :: f = x`
`static Rop`	`PUT_STATIC_LONG` `f: static field spec of type long; x: long :: f = x`
`static Rop`	`PUT_STATIC_OBJECT` `f: static field spec of type Object; x: Object :: f = x`
`static Rop`	`PUT_STATIC_SHORT` `f: static field spec of type short; x: short :: f = x`
`static Rop`	`REM_CONST_DOUBLE` `r,x,c: double :: r = x % c;`
`static Rop`	`REM_CONST_FLOAT` `r,x,c: float :: r = x % c;`
`static Rop`	`REM_CONST_INT` `r,x,c: int :: r = x % c;`
`static Rop`	`REM_CONST_LONG` `r,x,c: long :: r = x % c;`
`static Rop`	`REM_DOUBLE` `r,x,y: double :: r = x % y;`
`static Rop`	`REM_FLOAT` `r,x,y: float :: r = x % y;`
`static Rop`	`REM_INT` `r,x,y: int :: r = x % y;`
`static Rop`	`REM_LONG` `r,x,y: long :: r = x % y;`
`static Rop`	`RETURN_DOUBLE` `x: double; return x`
`static Rop`	`RETURN_FLOAT` `x: float; return x`
`static Rop`	`RETURN_INT` `x: int; return x`
`static Rop`	`RETURN_LONG` `x: long; return x`
`static Rop`	`RETURN_OBJECT` `x: Object; return x`
`static Rop`	`RETURN_VOID` `return void`
`static Rop`	`SHL_CONST_INT` `r,x,c: int :: r = x << c;`
`static Rop`	`SHL_CONST_LONG` `r,x: long; c: int :: r = x << c;`
`static Rop`	`SHL_INT` `r,x,y: int :: r = x << y;`
`static Rop`	`SHL_LONG` `r,x: long; y: int :: r = x << y;`
`static Rop`	`SHR_CONST_INT` `r,x,c: int :: r = x >> c;`
`static Rop`	`SHR_CONST_LONG` `r,x: long; c: int :: r = x >> c;`
`static Rop`	`SHR_INT` `r,x,y: int :: r = x >> y;`
`static Rop`	`SHR_LONG` `r,x: long; y: int :: r = x >> y;`
`static Rop`	`SUB_CONST_DOUBLE` `r,x,c: double :: r = x - c;`
`static Rop`	`SUB_CONST_FLOAT` `r,x,c: float :: r = x - c;`
`static Rop`	`SUB_CONST_INT` `r,x,c: int :: r = x - c;`
`static Rop`	`SUB_CONST_LONG` `r,x,c: long :: r = x - c;`
`static Rop`	`SUB_DOUBLE` `r,x,y: double :: r = x - y;`
`static Rop`	`SUB_FLOAT` `r,x,y: float :: r = x - y;`
`static Rop`	`SUB_INT` `r,x,y: int :: r = x - y;`
`static Rop`	`SUB_LONG` `r,x,y: long :: r = x - y;`
`static Rop`	`SWITCH` `x: int :: goto switchtable[x]`
`static Rop`	`THROW` `x: Throwable :: throw(x)`
`static Rop`	`TO_BYTE` `r,x: int :: r = (x << 24) >> 24` (Java-style convert int to byte)
`static Rop`	`TO_CHAR` `r,x: int :: r = x & 0xffff` (Java-style convert int to char)
`static Rop`	`TO_SHORT` `r,x: int :: r = (x << 16) >> 16` (Java-style convert int to short)
`static Rop`	`USHR_CONST_INT` `r,x,c: int :: r = x >>> c;`
`static Rop`	`USHR_CONST_LONG` `r,x: long; c: int :: r = x >>> c;`
`static Rop`	`USHR_INT` `r,x,y: int :: r = x >>> y;`
`static Rop`	`USHR_LONG` `r,x: long; y: int :: r = x >>> y;`
`static Rop`	`XOR_CONST_INT` `r,x,c: int :: r = x ^ c;`
`static Rop`	`XOR_CONST_LONG` `r,x,c: long :: r = x ^ c;`
`static Rop`	`XOR_INT` `r,x,y: int :: r = x ^ y;`
`static Rop`	`XOR_LONG` `r,x,y: long :: r = x ^ y;`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Rop`	`opAdd(TypeList types)` Returns the appropriate `add` rop for the given types.
`static Rop`	`opAget(TypeBearer type)` Returns the appropriate `aget` rop for the given type.
`static Rop`	`opAnd(TypeList types)` Returns the appropriate `and` rop for the given types.
`static Rop`	`opAput(TypeBearer type)` Returns the appropriate `aput` rop for the given type.
`static Rop`	`opCmpg(TypeBearer type)` Returns the appropriate `cmpg` rop for the given type.
`static Rop`	`opCmpl(TypeBearer type)` Returns the appropriate `cmpl` rop for the given type.
`static Rop`	`opConst(TypeBearer type)` Returns the appropriate `const` rop for the given type.
`static Rop`	`opConv(TypeBearer dest, TypeBearer source)` Returns the appropriate `conv` rop for the given types.
`static Rop`	`opDiv(TypeList types)` Returns the appropriate `div` rop for the given types.
`static Rop`	`opFilledNewArray(TypeBearer arrayType, int count)` Returns the appropriate `filled-new-array` rop for the given type.
`static Rop`	`opGetField(TypeBearer type)` Returns the appropriate `get-field` rop for the given type.
`static Rop`	`opGetStatic(TypeBearer type)` Returns the appropriate `get-static` rop for the given type.
`static Rop`	`opIfEq(TypeList types)` Returns the appropriate `if-eq` rop for the given sources.
`static Rop`	`opIfGe(TypeList types)` Returns the appropriate `if-ge` rop for the given sources.
`static Rop`	`opIfGt(TypeList types)` Returns the appropriate `if-gt` rop for the given sources.
`static Rop`	`opIfLe(TypeList types)` Returns the appropriate `if-le` rop for the given sources.
`static Rop`	`opIfLt(TypeList types)` Returns the appropriate `if-lt` rop for the given sources.
`static Rop`	`opIfNe(TypeList types)` Returns the appropriate `if-ne` rop for the given sources.
`static Rop`	`opInvokeDirect(Prototype meth)` Returns the appropriate `invoke-direct` rop for the given type.
`static Rop`	`opInvokeInterface(Prototype meth)` Returns the appropriate `invoke-interface` rop for the given type.
`static Rop`	`opInvokePolymorphic(Prototype meth)` Returns the appropriate `invoke-polymorphic` rop for the given type.
`static Rop`	`opInvokeStatic(Prototype meth)` Returns the appropriate `invoke-static` rop for the given type.
`static Rop`	`opInvokeSuper(Prototype meth)` Returns the appropriate `invoke-super` rop for the given type.
`static Rop`	`opInvokeVirtual(Prototype meth)` Returns the appropriate `invoke-virtual` rop for the given type.
`static Rop`	`opMarkLocal(TypeBearer type)` Returns the appropriate `mark-local` rop for the given type.
`static Rop`	`opMove(TypeBearer type)` Returns the appropriate `move` rop for the given type.
`static Rop`	`opMoveException(TypeBearer type)` Returns the appropriate `move-exception` rop for the given type.
`static Rop`	`opMoveParam(TypeBearer type)` Returns the appropriate `move-param` rop for the given type.
`static Rop`	`opMoveResult(TypeBearer type)` Returns the appropriate `move-result` rop for the given type.
`static Rop`	`opMoveResultPseudo(TypeBearer type)` Returns the appropriate `move-result-pseudo` rop for the given type.
`static Rop`	`opMul(TypeList types)` Returns the appropriate `mul` rop for the given types.
`static Rop`	`opNeg(TypeBearer type)` Returns the appropriate `neg` rop for the given type.
`static Rop`	`opNewArray(TypeBearer arrayType)` Returns the appropriate `new-array` rop for the given type.
`static Rop`	`opNot(TypeBearer type)` Returns the appropriate `not` rop for the given type.
`static Rop`	`opOr(TypeList types)` Returns the appropriate `or` rop for the given types.
`static Rop`	`opPutField(TypeBearer type)` Returns the appropriate `put-field` rop for the given type.
`static Rop`	`opPutStatic(TypeBearer type)` Returns the appropriate `put-static` rop for the given type.
`static Rop`	`opRem(TypeList types)` Returns the appropriate `rem` rop for the given types.
`static Rop`	`opReturn(TypeBearer type)` Returns the appropriate `return` rop for the given type.
`static Rop`	`opShl(TypeList types)` Returns the appropriate `shl` rop for the given types.
`static Rop`	`opShr(TypeList types)` Returns the appropriate `shr` rop for the given types.
`static Rop`	`opSub(TypeList types)` Returns the appropriate `sub` rop for the given types.
`static Rop`	`opUshr(TypeList types)` Returns the appropriate `ushr` rop for the given types.
`static Rop`	`opXor(TypeList types)` Returns the appropriate `xor` rop for the given types.
`static Rop`	`ropFor(int opcode, TypeBearer dest, TypeList sources, Constant cst)` Returns the appropriate rop for the given opcode, destination, and sources.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NOP
```
public static final Rop NOP
```
    nop()
  - MOVE_INT
```
public static final Rop MOVE_INT
```
    r,x: int :: r = x;
  - MOVE_LONG
```
public static final Rop MOVE_LONG
```
    r,x: long :: r = x;
  - MOVE_FLOAT
```
public static final Rop MOVE_FLOAT
```
    r,x: float :: r = x;
  - MOVE_DOUBLE
```
public static final Rop MOVE_DOUBLE
```
    r,x: double :: r = x;
  - MOVE_OBJECT
```
public static final Rop MOVE_OBJECT
```
    r,x: Object :: r = x;
  - MOVE_RETURN_ADDRESS
```
public static final Rop MOVE_RETURN_ADDRESS
```
    r,x: ReturnAddress :: r = x; Note that this rop-form instruction has no dex-form equivilent and must be removed before the dex conversion.
  - MOVE_PARAM_INT
```
public static final Rop MOVE_PARAM_INT
```
    r,param(x): int :: r = param(x);
  - MOVE_PARAM_LONG
```
public static final Rop MOVE_PARAM_LONG
```
    r,param(x): long :: r = param(x);
  - MOVE_PARAM_FLOAT
```
public static final Rop MOVE_PARAM_FLOAT
```
    r,param(x): float :: r = param(x);
  - MOVE_PARAM_DOUBLE
```
public static final Rop MOVE_PARAM_DOUBLE
```
    r,param(x): double :: r = param(x);
  - MOVE_PARAM_OBJECT
```
public static final Rop MOVE_PARAM_OBJECT
```
    r,param(x): Object :: r = param(x);
  - CONST_INT
```
public static final Rop CONST_INT
```
    r, literal: int :: r = literal;
  - CONST_LONG
```
public static final Rop CONST_LONG
```
    r, literal: long :: r = literal;
  - CONST_FLOAT
```
public static final Rop CONST_FLOAT
```
    r, literal: float :: r = literal;
  - CONST_DOUBLE
```
public static final Rop CONST_DOUBLE
```
    r, literal: double :: r = literal;
  - CONST_OBJECT
```
public static final Rop CONST_OBJECT
```
    r, literal: Object :: r = literal;
  - CONST_OBJECT_NOTHROW
```
public static final Rop CONST_OBJECT_NOTHROW
```
    r, literal: Object :: r = literal;
  - GOTO
```
public static final Rop GOTO
```
    goto label
  - IF_EQZ_INT
```
public static final Rop IF_EQZ_INT
```
    x: int :: if (x == 0) goto label
  - IF_NEZ_INT
```
public static final Rop IF_NEZ_INT
```
    x: int :: if (x != 0) goto label
  - IF_LTZ_INT
```
public static final Rop IF_LTZ_INT
```
    x: int :: if (x < 0) goto label
  - IF_GEZ_INT
```
public static final Rop IF_GEZ_INT
```
    x: int :: if (x >= 0) goto label
  - IF_LEZ_INT
```
public static final Rop IF_LEZ_INT
```
    x: int :: if (x <= 0) goto label
  - IF_GTZ_INT
```
public static final Rop IF_GTZ_INT
```
    x: int :: if (x > 0) goto label
  - IF_EQZ_OBJECT
```
public static final Rop IF_EQZ_OBJECT
```
    x: Object :: if (x == null) goto label
  - IF_NEZ_OBJECT
```
public static final Rop IF_NEZ_OBJECT
```
    x: Object :: if (x != null) goto label
  - IF_EQ_INT
```
public static final Rop IF_EQ_INT
```
    x,y: int :: if (x == y) goto label
  - IF_NE_INT
```
public static final Rop IF_NE_INT
```
    x,y: int :: if (x != y) goto label
  - IF_LT_INT
```
public static final Rop IF_LT_INT
```
    x,y: int :: if (x < y) goto label
  - IF_GE_INT
```
public static final Rop IF_GE_INT
```
    x,y: int :: if (x >= y) goto label
  - IF_LE_INT
```
public static final Rop IF_LE_INT
```
    x,y: int :: if (x <= y) goto label
  - IF_GT_INT
```
public static final Rop IF_GT_INT
```
    x,y: int :: if (x > y) goto label
  - IF_EQ_OBJECT
```
public static final Rop IF_EQ_OBJECT
```
    x,y: Object :: if (x == y) goto label
  - IF_NE_OBJECT
```
public static final Rop IF_NE_OBJECT
```
    x,y: Object :: if (x != y) goto label
  - SWITCH
```
public static final Rop SWITCH
```
    x: int :: goto switchtable[x]
  - ADD_INT
```
public static final Rop ADD_INT
```
    r,x,y: int :: r = x + y;
  - ADD_LONG
```
public static final Rop ADD_LONG
```
    r,x,y: long :: r = x + y;
  - ADD_FLOAT
```
public static final Rop ADD_FLOAT
```
    r,x,y: float :: r = x + y;
  - ADD_DOUBLE
```
public static final Rop ADD_DOUBLE
```
    r,x,y: double :: r = x + y;
  - SUB_INT
```
public static final Rop SUB_INT
```
    r,x,y: int :: r = x - y;
  - SUB_LONG
```
public static final Rop SUB_LONG
```
    r,x,y: long :: r = x - y;
  - SUB_FLOAT
```
public static final Rop SUB_FLOAT
```
    r,x,y: float :: r = x - y;
  - SUB_DOUBLE
```
public static final Rop SUB_DOUBLE
```
    r,x,y: double :: r = x - y;
  - MUL_INT
```
public static final Rop MUL_INT
```
    r,x,y: int :: r = x * y;
  - MUL_LONG
```
public static final Rop MUL_LONG
```
    r,x,y: long :: r = x * y;
  - MUL_FLOAT
```
public static final Rop MUL_FLOAT
```
    r,x,y: float :: r = x * y;
  - MUL_DOUBLE
```
public static final Rop MUL_DOUBLE
```
    r,x,y: double :: r = x * y;
  - DIV_INT
```
public static final Rop DIV_INT
```
    r,x,y: int :: r = x / y;
  - DIV_LONG
```
public static final Rop DIV_LONG
```
    r,x,y: long :: r = x / y;
  - DIV_FLOAT
```
public static final Rop DIV_FLOAT
```
    r,x,y: float :: r = x / y;
  - DIV_DOUBLE
```
public static final Rop DIV_DOUBLE
```
    r,x,y: double :: r = x / y;
  - REM_INT
```
public static final Rop REM_INT
```
    r,x,y: int :: r = x % y;
  - REM_LONG
```
public static final Rop REM_LONG
```
    r,x,y: long :: r = x % y;
  - REM_FLOAT
```
public static final Rop REM_FLOAT
```
    r,x,y: float :: r = x % y;
  - REM_DOUBLE
```
public static final Rop REM_DOUBLE
```
    r,x,y: double :: r = x % y;
  - NEG_INT
```
public static final Rop NEG_INT
```
    r,x: int :: r = -x;
  - NEG_LONG
```
public static final Rop NEG_LONG
```
    r,x: long :: r = -x;
  - NEG_FLOAT
```
public static final Rop NEG_FLOAT
```
    r,x: float :: r = -x;
  - NEG_DOUBLE
```
public static final Rop NEG_DOUBLE
```
    r,x: double :: r = -x;
  - AND_INT
```
public static final Rop AND_INT
```
    r,x,y: int :: r = x & y;
  - AND_LONG
```
public static final Rop AND_LONG
```
    r,x,y: long :: r = x & y;
  - OR_INT
```
public static final Rop OR_INT
```
    r,x,y: int :: r = x | y;
  - OR_LONG
```
public static final Rop OR_LONG
```
    r,x,y: long :: r = x | y;
  - XOR_INT
```
public static final Rop XOR_INT
```
    r,x,y: int :: r = x ^ y;
  - XOR_LONG
```
public static final Rop XOR_LONG
```
    r,x,y: long :: r = x ^ y;
  - SHL_INT
```
public static final Rop SHL_INT
```
    r,x,y: int :: r = x << y;
  - SHL_LONG
```
public static final Rop SHL_LONG
```
    r,x: long; y: int :: r = x << y;
  - SHR_INT
```
public static final Rop SHR_INT
```
    r,x,y: int :: r = x >> y;
  - SHR_LONG
```
public static final Rop SHR_LONG
```
    r,x: long; y: int :: r = x >> y;
  - USHR_INT
```
public static final Rop USHR_INT
```
    r,x,y: int :: r = x >>> y;
  - USHR_LONG
```
public static final Rop USHR_LONG
```
    r,x: long; y: int :: r = x >>> y;
  - NOT_INT
```
public static final Rop NOT_INT
```
    r,x: int :: r = ~x;
  - NOT_LONG
```
public static final Rop NOT_LONG
```
    r,x: long :: r = ~x;
  - ADD_CONST_INT
```
public static final Rop ADD_CONST_INT
```
    r,x,c: int :: r = x + c;
  - ADD_CONST_LONG
```
public static final Rop ADD_CONST_LONG
```
    r,x,c: long :: r = x + c;
  - ADD_CONST_FLOAT
```
public static final Rop ADD_CONST_FLOAT
```
    r,x,c: float :: r = x + c;
  - ADD_CONST_DOUBLE
```
public static final Rop ADD_CONST_DOUBLE
```
    r,x,c: double :: r = x + c;
  - SUB_CONST_INT
```
public static final Rop SUB_CONST_INT
```
    r,x,c: int :: r = x - c;
  - SUB_CONST_LONG
```
public static final Rop SUB_CONST_LONG
```
    r,x,c: long :: r = x - c;
  - SUB_CONST_FLOAT
```
public static final Rop SUB_CONST_FLOAT
```
    r,x,c: float :: r = x - c;
  - SUB_CONST_DOUBLE
```
public static final Rop SUB_CONST_DOUBLE
```
    r,x,c: double :: r = x - c;
  - MUL_CONST_INT
```
public static final Rop MUL_CONST_INT
```
    r,x,c: int :: r = x * c;
  - MUL_CONST_LONG
```
public static final Rop MUL_CONST_LONG
```
    r,x,c: long :: r = x * c;
  - MUL_CONST_FLOAT
```
public static final Rop MUL_CONST_FLOAT
```
    r,x,c: float :: r = x * c;
  - MUL_CONST_DOUBLE
```
public static final Rop MUL_CONST_DOUBLE
```
    r,x,c: double :: r = x * c;
  - DIV_CONST_INT
```
public static final Rop DIV_CONST_INT
```
    r,x,c: int :: r = x / c;
  - DIV_CONST_LONG
```
public static final Rop DIV_CONST_LONG
```
    r,x,c: long :: r = x / c;
  - DIV_CONST_FLOAT
```
public static final Rop DIV_CONST_FLOAT
```
    r,x,c: float :: r = x / c;
  - DIV_CONST_DOUBLE
```
public static final Rop DIV_CONST_DOUBLE
```
    r,x,c: double :: r = x / c;
  - REM_CONST_INT
```
public static final Rop REM_CONST_INT
```
    r,x,c: int :: r = x % c;
  - REM_CONST_LONG
```
public static final Rop REM_CONST_LONG
```
    r,x,c: long :: r = x % c;
  - REM_CONST_FLOAT
```
public static final Rop REM_CONST_FLOAT
```
    r,x,c: float :: r = x % c;
  - REM_CONST_DOUBLE
```
public static final Rop REM_CONST_DOUBLE
```
    r,x,c: double :: r = x % c;
  - AND_CONST_INT
```
public static final Rop AND_CONST_INT
```
    r,x,c: int :: r = x & c;
  - AND_CONST_LONG
```
public static final Rop AND_CONST_LONG
```
    r,x,c: long :: r = x & c;
  - OR_CONST_INT
```
public static final Rop OR_CONST_INT
```
    r,x,c: int :: r = x | c;
  - OR_CONST_LONG
```
public static final Rop OR_CONST_LONG
```
    r,x,c: long :: r = x | c;
  - XOR_CONST_INT
```
public static final Rop XOR_CONST_INT
```
    r,x,c: int :: r = x ^ c;
  - XOR_CONST_LONG
```
public static final Rop XOR_CONST_LONG
```
    r,x,c: long :: r = x ^ c;
  - SHL_CONST_INT
```
public static final Rop SHL_CONST_INT
```
    r,x,c: int :: r = x << c;
  - SHL_CONST_LONG
```
public static final Rop SHL_CONST_LONG
```
    r,x: long; c: int :: r = x << c;
  - SHR_CONST_INT
```
public static final Rop SHR_CONST_INT
```
    r,x,c: int :: r = x >> c;
  - SHR_CONST_LONG
```
public static final Rop SHR_CONST_LONG
```
    r,x: long; c: int :: r = x >> c;
  - USHR_CONST_INT
```
public static final Rop USHR_CONST_INT
```
    r,x,c: int :: r = x >>> c;
  - USHR_CONST_LONG
```
public static final Rop USHR_CONST_LONG
```
    r,x: long; c: int :: r = x >>> c;
  - CMPL_LONG
```
public static final Rop CMPL_LONG
```
    r: int; x,y: long :: r = cmp(x, y);
  - CMPL_FLOAT
```
public static final Rop CMPL_FLOAT
```
    r: int; x,y: float :: r = cmpl(x, y);
  - CMPL_DOUBLE
```
public static final Rop CMPL_DOUBLE
```
    r: int; x,y: double :: r = cmpl(x, y);
  - CMPG_FLOAT
```
public static final Rop CMPG_FLOAT
```
    r: int; x,y: float :: r = cmpg(x, y);
  - CMPG_DOUBLE
```
public static final Rop CMPG_DOUBLE
```
    r: int; x,y: double :: r = cmpg(x, y);
  - CONV_L2I
```
public static final Rop CONV_L2I
```
    r: int; x: long :: r = (int) x
  - CONV_F2I
```
public static final Rop CONV_F2I
```
    r: int; x: float :: r = (int) x
  - CONV_D2I
```
public static final Rop CONV_D2I
```
    r: int; x: double :: r = (int) x
  - CONV_I2L
```
public static final Rop CONV_I2L
```
    r: long; x: int :: r = (long) x
  - CONV_F2L
```
public static final Rop CONV_F2L
```
    r: long; x: float :: r = (long) x
  - CONV_D2L
```
public static final Rop CONV_D2L
```
    r: long; x: double :: r = (long) x
  - CONV_I2F
```
public static final Rop CONV_I2F
```
    r: float; x: int :: r = (float) x
  - CONV_L2F
```
public static final Rop CONV_L2F
```
    r: float; x: long :: r = (float) x
  - CONV_D2F
```
public static final Rop CONV_D2F
```
    r: float; x: double :: r = (float) x
  - CONV_I2D
```
public static final Rop CONV_I2D
```
    r: double; x: int :: r = (double) x
  - CONV_L2D
```
public static final Rop CONV_L2D
```
    r: double; x: long :: r = (double) x
  - CONV_F2D
```
public static final Rop CONV_F2D
```
    r: double; x: float :: r = (double) x
  - TO_BYTE
```
public static final Rop TO_BYTE
```
    r,x: int :: r = (x << 24) >> 24 (Java-style convert int to byte)
  - TO_CHAR
```
public static final Rop TO_CHAR
```
    r,x: int :: r = x & 0xffff (Java-style convert int to char)
  - TO_SHORT
```
public static final Rop TO_SHORT
```
    r,x: int :: r = (x << 16) >> 16 (Java-style convert int to short)
  - RETURN_VOID
```
public static final Rop RETURN_VOID
```
    return void
  - RETURN_INT
```
public static final Rop RETURN_INT
```
    x: int; return x
  - RETURN_LONG
```
public static final Rop RETURN_LONG
```
    x: long; return x
  - RETURN_FLOAT
```
public static final Rop RETURN_FLOAT
```
    x: float; return x
  - RETURN_DOUBLE
```
public static final Rop RETURN_DOUBLE
```
    x: double; return x
  - RETURN_OBJECT
```
public static final Rop RETURN_OBJECT
```
    x: Object; return x
  - ARRAY_LENGTH
```
public static final Rop ARRAY_LENGTH
```
    T: any type; r: int; x: T[]; :: r = x.length
  - THROW
```
public static final Rop THROW
```
    x: Throwable :: throw(x)
  - MONITOR_ENTER
```
public static final Rop MONITOR_ENTER
```
    x: Object :: monitorenter(x)
  - MONITOR_EXIT
```
public static final Rop MONITOR_EXIT
```
    x: Object :: monitorexit(x)
  - AGET_INT
```
public static final Rop AGET_INT
```
    r,y: int; x: int[] :: r = x[y]
  - AGET_LONG
```
public static final Rop AGET_LONG
```
    r: long; x: long[]; y: int :: r = x[y]
  - AGET_FLOAT
```
public static final Rop AGET_FLOAT
```
    r: float; x: float[]; y: int :: r = x[y]
  - AGET_DOUBLE
```
public static final Rop AGET_DOUBLE
```
    r: double; x: double[]; y: int :: r = x[y]
  - AGET_OBJECT
```
public static final Rop AGET_OBJECT
```
    r: Object; x: Object[]; y: int :: r = x[y]
  - AGET_BOOLEAN
```
public static final Rop AGET_BOOLEAN
```
    r: boolean; x: boolean[]; y: int :: r = x[y]
  - AGET_BYTE
```
public static final Rop AGET_BYTE
```
    r: byte; x: byte[]; y: int :: r = x[y]
  - AGET_CHAR
```
public static final Rop AGET_CHAR
```
    r: char; x: char[]; y: int :: r = x[y]
  - AGET_SHORT
```
public static final Rop AGET_SHORT
```
    r: short; x: short[]; y: int :: r = x[y]
  - APUT_INT
```
public static final Rop APUT_INT
```
    x,z: int; y: int[] :: y[z] = x
  - APUT_LONG
```
public static final Rop APUT_LONG
```
    x: long; y: long[]; z: int :: y[z] = x
  - APUT_FLOAT
```
public static final Rop APUT_FLOAT
```
    x: float; y: float[]; z: int :: y[z] = x
  - APUT_DOUBLE
```
public static final Rop APUT_DOUBLE
```
    x: double; y: double[]; z: int :: y[z] = x
  - APUT_OBJECT
```
public static final Rop APUT_OBJECT
```
    x: Object; y: Object[]; z: int :: y[z] = x
  - APUT_BOOLEAN
```
public static final Rop APUT_BOOLEAN
```
    x: boolean; y: boolean[]; z: int :: y[z] = x
  - APUT_BYTE
```
public static final Rop APUT_BYTE
```
    x: byte; y: byte[]; z: int :: y[z] = x
  - APUT_CHAR
```
public static final Rop APUT_CHAR
```
    x: char; y: char[]; z: int :: y[z] = x
  - APUT_SHORT
```
public static final Rop APUT_SHORT
```
    x: short; y: short[]; z: int :: y[z] = x
  - NEW_INSTANCE
```
public static final Rop NEW_INSTANCE
```
    T: any non-array object type :: r = alloc(T) (allocate heap space for an object)
  - NEW_ARRAY_INT
```
public static final Rop NEW_ARRAY_INT
```
    r: int[]; x: int :: r = new int[x]
  - NEW_ARRAY_LONG
```
public static final Rop NEW_ARRAY_LONG
```
    r: long[]; x: int :: r = new long[x]
  - NEW_ARRAY_FLOAT
```
public static final Rop NEW_ARRAY_FLOAT
```
    r: float[]; x: int :: r = new float[x]
  - NEW_ARRAY_DOUBLE
```
public static final Rop NEW_ARRAY_DOUBLE
```
    r: double[]; x: int :: r = new double[x]
  - NEW_ARRAY_BOOLEAN
```
public static final Rop NEW_ARRAY_BOOLEAN
```
    r: boolean[]; x: int :: r = new boolean[x]
  - NEW_ARRAY_BYTE
```
public static final Rop NEW_ARRAY_BYTE
```
    r: byte[]; x: int :: r = new byte[x]
  - NEW_ARRAY_CHAR
```
public static final Rop NEW_ARRAY_CHAR
```
    r: char[]; x: int :: r = new char[x]
  - NEW_ARRAY_SHORT
```
public static final Rop NEW_ARRAY_SHORT
```
    r: short[]; x: int :: r = new short[x]
  - CHECK_CAST
```
public static final Rop CHECK_CAST
```
    T: any non-array object type; x: Object :: (T) x (can throw ClassCastException)
  - INSTANCE_OF
```
public static final Rop INSTANCE_OF
```
    T: any non-array object type; x: Object :: x instanceof T. Note: This is listed as throwing Error explicitly because the op can throw, but there are no other predefined exceptions for it.
  - GET_FIELD_INT
```
public static final Rop GET_FIELD_INT
```
    r: int; x: Object; f: instance field spec of type int :: r = x.f
  - GET_FIELD_LONG
```
public static final Rop GET_FIELD_LONG
```
    r: long; x: Object; f: instance field spec of type long :: r = x.f
  - GET_FIELD_FLOAT
```
public static final Rop GET_FIELD_FLOAT
```
    r: float; x: Object; f: instance field spec of type float :: r = x.f
  - GET_FIELD_DOUBLE
```
public static final Rop GET_FIELD_DOUBLE
```
    r: double; x: Object; f: instance field spec of type double :: r = x.f
  - GET_FIELD_OBJECT
```
public static final Rop GET_FIELD_OBJECT
```
    r: Object; x: Object; f: instance field spec of type Object :: r = x.f
  - GET_FIELD_BOOLEAN
```
public static final Rop GET_FIELD_BOOLEAN
```
    r: boolean; x: Object; f: instance field spec of type boolean :: r = x.f
  - GET_FIELD_BYTE
```
public static final Rop GET_FIELD_BYTE
```
    r: byte; x: Object; f: instance field spec of type byte :: r = x.f
  - GET_FIELD_CHAR
```
public static final Rop GET_FIELD_CHAR
```
    r: char; x: Object; f: instance field spec of type char :: r = x.f
  - GET_FIELD_SHORT
```
public static final Rop GET_FIELD_SHORT
```
    r: short; x: Object; f: instance field spec of type short :: r = x.f
  - GET_STATIC_INT
```
public static final Rop GET_STATIC_INT
```
    r: int; f: static field spec of type int :: r = f
  - GET_STATIC_LONG
```
public static final Rop GET_STATIC_LONG
```
    r: long; f: static field spec of type long :: r = f
  - GET_STATIC_FLOAT
```
public static final Rop GET_STATIC_FLOAT
```
    r: float; f: static field spec of type float :: r = f
  - GET_STATIC_DOUBLE
```
public static final Rop GET_STATIC_DOUBLE
```
    r: double; f: static field spec of type double :: r = f
  - GET_STATIC_OBJECT
```
public static final Rop GET_STATIC_OBJECT
```
    r: Object; f: static field spec of type Object :: r = f
  - GET_STATIC_BOOLEAN
```
public static final Rop GET_STATIC_BOOLEAN
```
    r: boolean; f: static field spec of type boolean :: r = f
  - GET_STATIC_BYTE
```
public static final Rop GET_STATIC_BYTE
```
    r: byte; f: static field spec of type byte :: r = f
  - GET_STATIC_CHAR
```
public static final Rop GET_STATIC_CHAR
```
    r: char; f: static field spec of type char :: r = f
  - GET_STATIC_SHORT
```
public static final Rop GET_STATIC_SHORT
```
    r: short; f: static field spec of type short :: r = f
  - PUT_FIELD_INT
```
public static final Rop PUT_FIELD_INT
```
    x: int; y: Object; f: instance field spec of type int :: y.f = x
  - PUT_FIELD_LONG
```
public static final Rop PUT_FIELD_LONG
```
    x: long; y: Object; f: instance field spec of type long :: y.f = x
  - PUT_FIELD_FLOAT
```
public static final Rop PUT_FIELD_FLOAT
```
    x: float; y: Object; f: instance field spec of type float :: y.f = x
  - PUT_FIELD_DOUBLE
```
public static final Rop PUT_FIELD_DOUBLE
```
    x: double; y: Object; f: instance field spec of type double :: y.f = x
  - PUT_FIELD_OBJECT
```
public static final Rop PUT_FIELD_OBJECT
```
    x: Object; y: Object; f: instance field spec of type Object :: y.f = x
  - PUT_FIELD_BOOLEAN
```
public static final Rop PUT_FIELD_BOOLEAN
```
    x: int; y: Object; f: instance field spec of type boolean :: y.f = x
  - PUT_FIELD_BYTE
```
public static final Rop PUT_FIELD_BYTE
```
    x: int; y: Object; f: instance field spec of type byte :: y.f = x
  - PUT_FIELD_CHAR
```
public static final Rop PUT_FIELD_CHAR
```
    x: int; y: Object; f: instance field spec of type char :: y.f = x
  - PUT_FIELD_SHORT
```
public static final Rop PUT_FIELD_SHORT
```
    x: int; y: Object; f: instance field spec of type short :: y.f = x
  - PUT_STATIC_INT
```
public static final Rop PUT_STATIC_INT
```
    f: static field spec of type int; x: int :: f = x
  - PUT_STATIC_LONG
```
public static final Rop PUT_STATIC_LONG
```
    f: static field spec of type long; x: long :: f = x
  - PUT_STATIC_FLOAT
```
public static final Rop PUT_STATIC_FLOAT
```
    f: static field spec of type float; x: float :: f = x
  - PUT_STATIC_DOUBLE
```
public static final Rop PUT_STATIC_DOUBLE
```
    f: static field spec of type double; x: double :: f = x
  - PUT_STATIC_OBJECT
```
public static final Rop PUT_STATIC_OBJECT
```
    f: static field spec of type Object; x: Object :: f = x
  - PUT_STATIC_BOOLEAN
```
public static final Rop PUT_STATIC_BOOLEAN
```
    f: static field spec of type boolean; x: boolean :: f = x
  - PUT_STATIC_BYTE
```
public static final Rop PUT_STATIC_BYTE
```
    f: static field spec of type byte; x: byte :: f = x
  - PUT_STATIC_CHAR
```
public static final Rop PUT_STATIC_CHAR
```
    f: static field spec of type char; x: char :: f = x
  - PUT_STATIC_SHORT
```
public static final Rop PUT_STATIC_SHORT
```
    f: static field spec of type short; x: short :: f = x
  - MARK_LOCAL_INT
```
public static final Rop MARK_LOCAL_INT
```
    x: Int :: local variable begins in x
  - MARK_LOCAL_LONG
```
public static final Rop MARK_LOCAL_LONG
```
    x: Long :: local variable begins in x
  - MARK_LOCAL_FLOAT
```
public static final Rop MARK_LOCAL_FLOAT
```
    x: Float :: local variable begins in x
  - MARK_LOCAL_DOUBLE
```
public static final Rop MARK_LOCAL_DOUBLE
```
    x: Double :: local variable begins in x
  - MARK_LOCAL_OBJECT
```
public static final Rop MARK_LOCAL_OBJECT
```
    x: Object :: local variable begins in x
  - FILL_ARRAY_DATA
```
public static final Rop FILL_ARRAY_DATA
```
    T: Any primitive type; v0..vx: T :: {v0, ..., vx}
- Method Detail
  - ropFor
```
public static Rop ropFor(int opcode,
                         TypeBearer dest,
                         TypeList sources,
                         Constant cst)
```
    Returns the appropriate rop for the given opcode, destination, and sources. The result is typically, but not necessarily, a shared instance.
    Note: This method does not do complete error checking on its arguments, and so it may return an instance which seemed "right enough" even though in actuality the passed arguments don't quite match what is returned. TODO: Revisit this issue.
    
    Parameters:
    
    opcode - the opcode
    
    dest - non-null; destination (result) type, or Type.VOID if none
    
    sources - non-null; list of source types
    
    cst - null-ok; associated constant, if any
    
    Returns:
    
    non-null; an appropriate instance
  - opMove
```
public static Rop opMove(TypeBearer type)
```
    Returns the appropriate move rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being moved
    
    Returns:
    
    non-null; an appropriate instance
  - opMoveParam
```
public static Rop opMoveParam(TypeBearer type)
```
    Returns the appropriate move-param rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being moved
    
    Returns:
    
    non-null; an appropriate instance
  - opMoveException
```
public static Rop opMoveException(TypeBearer type)
```
    Returns the appropriate move-exception rop for the given type. The result may be a shared instance.
    
    Parameters:
    
    type - non-null; type of the exception
    
    Returns:
    
    non-null; an appropriate instance
  - opMoveResult
```
public static Rop opMoveResult(TypeBearer type)
```
    Returns the appropriate move-result rop for the given type. The result may be a shared instance.
    
    Parameters:
    
    type - non-null; type of the parameter
    
    Returns:
    
    non-null; an appropriate instance
  - opMoveResultPseudo
```
public static Rop opMoveResultPseudo(TypeBearer type)
```
    Returns the appropriate move-result-pseudo rop for the given type. The result may be a shared instance.
    
    Parameters:
    
    type - non-null; type of the parameter
    
    Returns:
    
    non-null; an appropriate instance
  - opConst
```
public static Rop opConst(TypeBearer type)
```
    Returns the appropriate const rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of the constant
    
    Returns:
    
    non-null; an appropriate instance
  - opIfEq
```
public static Rop opIfEq(TypeList types)
```
    Returns the appropriate if-eq rop for the given sources. The result is a shared instance.
    
    Parameters:
    
    types - non-null; source types
    
    Returns:
    
    non-null; an appropriate instance
  - opIfNe
```
public static Rop opIfNe(TypeList types)
```
    Returns the appropriate if-ne rop for the given sources. The result is a shared instance.
    
    Parameters:
    
    types - non-null; source types
    
    Returns:
    
    non-null; an appropriate instance
  - opIfLt
```
public static Rop opIfLt(TypeList types)
```
    Returns the appropriate if-lt rop for the given sources. The result is a shared instance.
    
    Parameters:
    
    types - non-null; source types
    
    Returns:
    
    non-null; an appropriate instance
  - opIfGe
```
public static Rop opIfGe(TypeList types)
```
    Returns the appropriate if-ge rop for the given sources. The result is a shared instance.
    
    Parameters:
    
    types - non-null; source types
    
    Returns:
    
    non-null; an appropriate instance
  - opIfGt
```
public static Rop opIfGt(TypeList types)
```
    Returns the appropriate if-gt rop for the given sources. The result is a shared instance.
    
    Parameters:
    
    types - non-null; source types
    
    Returns:
    
    non-null; an appropriate instance
  - opIfLe
```
public static Rop opIfLe(TypeList types)
```
    Returns the appropriate if-le rop for the given sources. The result is a shared instance.
    
    Parameters:
    
    types - non-null; source types
    
    Returns:
    
    non-null; an appropriate instance
  - opAdd
```
public static Rop opAdd(TypeList types)
```
    Returns the appropriate add rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opSub
```
public static Rop opSub(TypeList types)
```
    Returns the appropriate sub rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opMul
```
public static Rop opMul(TypeList types)
```
    Returns the appropriate mul rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opDiv
```
public static Rop opDiv(TypeList types)
```
    Returns the appropriate div rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opRem
```
public static Rop opRem(TypeList types)
```
    Returns the appropriate rem rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opAnd
```
public static Rop opAnd(TypeList types)
```
    Returns the appropriate and rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opOr
```
public static Rop opOr(TypeList types)
```
    Returns the appropriate or rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opXor
```
public static Rop opXor(TypeList types)
```
    Returns the appropriate xor rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opShl
```
public static Rop opShl(TypeList types)
```
    Returns the appropriate shl rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opShr
```
public static Rop opShr(TypeList types)
```
    Returns the appropriate shr rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opUshr
```
public static Rop opUshr(TypeList types)
```
    Returns the appropriate ushr rop for the given types. The result is a shared instance.
    
    Parameters:
    
    types - non-null; types of the sources
    
    Returns:
    
    non-null; an appropriate instance
  - opNeg
```
public static Rop opNeg(TypeBearer type)
```
    Returns the appropriate neg rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being operated on
    
    Returns:
    
    non-null; an appropriate instance
  - opNot
```
public static Rop opNot(TypeBearer type)
```
    Returns the appropriate not rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being operated on
    
    Returns:
    
    non-null; an appropriate instance
  - opCmpl
```
public static Rop opCmpl(TypeBearer type)
```
    Returns the appropriate cmpl rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being compared
    
    Returns:
    
    non-null; an appropriate instance
  - opCmpg
```
public static Rop opCmpg(TypeBearer type)
```
    Returns the appropriate cmpg rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being compared
    
    Returns:
    
    non-null; an appropriate instance
  - opConv
```
public static Rop opConv(TypeBearer dest,
                         TypeBearer source)
```
    Returns the appropriate conv rop for the given types. The result is a shared instance.
    
    Parameters:
    
    dest - non-null; target value type
    
    source - non-null; source value type
    
    Returns:
    
    non-null; an appropriate instance
  - opReturn
```
public static Rop opReturn(TypeBearer type)
```
    Returns the appropriate return rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being returned
    
    Returns:
    
    non-null; an appropriate instance
  - opAget
```
public static Rop opAget(TypeBearer type)
```
    Returns the appropriate aget rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; element type of array being accessed
    
    Returns:
    
    non-null; an appropriate instance
  - opAput
```
public static Rop opAput(TypeBearer type)
```
    Returns the appropriate aput rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; element type of array being accessed
    
    Returns:
    
    non-null; an appropriate instance
  - opNewArray
```
public static Rop opNewArray(TypeBearer arrayType)
```
    Returns the appropriate new-array rop for the given type. The result is a shared instance.
    
    Parameters:
    
    arrayType - non-null; array type of array being created
    
    Returns:
    
    non-null; an appropriate instance
  - opFilledNewArray
```
public static Rop opFilledNewArray(TypeBearer arrayType,
                                   int count)
```
    Returns the appropriate filled-new-array rop for the given type. The result may be a shared instance.
    
    Parameters:
    
    arrayType - non-null; type of array being created
    
    count - count >= 0; number of elements that the array should have
    
    Returns:
    
    non-null; an appropriate instance
  - opGetField
```
public static Rop opGetField(TypeBearer type)
```
    Returns the appropriate get-field rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of the field in question
    
    Returns:
    
    non-null; an appropriate instance
  - opPutField
```
public static Rop opPutField(TypeBearer type)
```
    Returns the appropriate put-field rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of the field in question
    
    Returns:
    
    non-null; an appropriate instance
  - opGetStatic
```
public static Rop opGetStatic(TypeBearer type)
```
    Returns the appropriate get-static rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of the field in question
    
    Returns:
    
    non-null; an appropriate instance
  - opPutStatic
```
public static Rop opPutStatic(TypeBearer type)
```
    Returns the appropriate put-static rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of the field in question
    
    Returns:
    
    non-null; an appropriate instance
  - opInvokeStatic
```
public static Rop opInvokeStatic(Prototype meth)
```
    Returns the appropriate invoke-static rop for the given type. The result is typically a newly-allocated instance.
    
    Parameters:
    
    meth - non-null; descriptor of the method
    
    Returns:
    
    non-null; an appropriate instance
  - opInvokeVirtual
```
public static Rop opInvokeVirtual(Prototype meth)
```
    Returns the appropriate invoke-virtual rop for the given type. The result is typically a newly-allocated instance.
    
    Parameters:
    
    meth - non-null; descriptor of the method, including the this parameter
    
    Returns:
    
    non-null; an appropriate instance
  - opInvokeSuper
```
public static Rop opInvokeSuper(Prototype meth)
```
    Returns the appropriate invoke-super rop for the given type. The result is typically a newly-allocated instance.
    
    Parameters:
    
    meth - non-null; descriptor of the method, including the this parameter
    
    Returns:
    
    non-null; an appropriate instance
  - opInvokeDirect
```
public static Rop opInvokeDirect(Prototype meth)
```
    Returns the appropriate invoke-direct rop for the given type. The result is typically a newly-allocated instance.
    
    Parameters:
    
    meth - non-null; descriptor of the method, including the this parameter
    
    Returns:
    
    non-null; an appropriate instance
  - opInvokeInterface
```
public static Rop opInvokeInterface(Prototype meth)
```
    Returns the appropriate invoke-interface rop for the given type. The result is typically a newly-allocated instance.
    
    Parameters:
    
    meth - non-null; descriptor of the method, including the this parameter
    
    Returns:
    
    non-null; an appropriate instance
  - opInvokePolymorphic
```
public static Rop opInvokePolymorphic(Prototype meth)
```
    Returns the appropriate invoke-polymorphic rop for the given type. The result is typically a newly-allocated instance.
    
    Parameters:
    
    meth - non-null; descriptor of the method, including the this parameter
    
    Returns:
    
    non-null; an appropriate instance
  - opMarkLocal
```
public static Rop opMarkLocal(TypeBearer type)
```
    Returns the appropriate mark-local rop for the given type. The result is a shared instance.
    
    Parameters:
    
    type - non-null; type of value being marked
    
    Returns:
    
    non-null; an appropriate instance

Class Rops

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NOP

MOVE_INT

MOVE_LONG

MOVE_FLOAT

MOVE_DOUBLE

MOVE_OBJECT

MOVE_RETURN_ADDRESS

MOVE_PARAM_INT

MOVE_PARAM_LONG

MOVE_PARAM_FLOAT

MOVE_PARAM_DOUBLE

MOVE_PARAM_OBJECT

CONST_INT

CONST_LONG

CONST_FLOAT

CONST_DOUBLE

CONST_OBJECT

CONST_OBJECT_NOTHROW

GOTO

IF_EQZ_INT

IF_NEZ_INT

IF_LTZ_INT

IF_GEZ_INT

IF_LEZ_INT

IF_GTZ_INT

IF_EQZ_OBJECT

IF_NEZ_OBJECT

IF_EQ_INT

IF_NE_INT

IF_LT_INT

IF_GE_INT

IF_LE_INT

IF_GT_INT

IF_EQ_OBJECT

IF_NE_OBJECT

SWITCH

ADD_INT

ADD_LONG

ADD_FLOAT

ADD_DOUBLE

SUB_INT

SUB_LONG

SUB_FLOAT

SUB_DOUBLE

MUL_INT

MUL_LONG

MUL_FLOAT

MUL_DOUBLE

DIV_INT

DIV_LONG

DIV_FLOAT

DIV_DOUBLE

REM_INT

REM_LONG

REM_FLOAT

REM_DOUBLE

NEG_INT

NEG_LONG

NEG_FLOAT

NEG_DOUBLE

AND_INT

AND_LONG

OR_INT

OR_LONG

XOR_INT

XOR_LONG

SHL_INT

SHL_LONG

SHR_INT

SHR_LONG

USHR_INT

USHR_LONG

NOT_INT

NOT_LONG

ADD_CONST_INT