/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.dx.rop.code;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstBaseMethodRef;
import com.android.dx.rop.cst.CstMethodRef;
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Prototype;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
import com.android.dx.rop.type.TypeList;
/**
* Standard instances of {@link Rop}.
*/
public final class Rops {
/** <code>nop()</code> */
public static final Rop NOP =
new Rop(RegOps.NOP, Type.VOID, StdTypeList.EMPTY, "nop");
/** <code>r,x: int :: r = x;</code> */
public static final Rop MOVE_INT =
new Rop(RegOps.MOVE, Type.INT, StdTypeList.INT, "move-int");
/** <code>r,x: long :: r = x;</code> */
public static final Rop MOVE_LONG =
new Rop(RegOps.MOVE, Type.LONG, StdTypeList.LONG, "move-long");
/** <code>r,x: float :: r = x;</code> */
public static final Rop MOVE_FLOAT =
new Rop(RegOps.MOVE, Type.FLOAT, StdTypeList.FLOAT, "move-float");
/** <code>r,x: double :: r = x;</code> */
public static final Rop MOVE_DOUBLE =
new Rop(RegOps.MOVE, Type.DOUBLE, StdTypeList.DOUBLE, "move-double");
/** <code>r,x: Object :: r = x;</code> */
public static final Rop MOVE_OBJECT =
new Rop(RegOps.MOVE, Type.OBJECT, StdTypeList.OBJECT, "move-object");
/**
* <code>r,x: ReturnAddress :: r = x;</code>
*
* Note that this rop-form instruction has no dex-form equivilent and
* must be removed before the dex conversion.
*/
public static final Rop MOVE_RETURN_ADDRESS =
new Rop(RegOps.MOVE, Type.RETURN_ADDRESS,
StdTypeList.RETURN_ADDRESS, "move-return-address");
/** <code>r,param(x): int :: r = param(x);</code> */
public static final Rop MOVE_PARAM_INT =
new Rop(RegOps.MOVE_PARAM, Type.INT, StdTypeList.EMPTY,
"move-param-int");
/** <code>r,param(x): long :: r = param(x);</code> */
public static final Rop MOVE_PARAM_LONG =
new Rop(RegOps.MOVE_PARAM, Type.LONG, StdTypeList.EMPTY,
"move-param-long");
/** <code>r,param(x): float :: r = param(x);</code> */
public static final Rop MOVE_PARAM_FLOAT =
new Rop(RegOps.MOVE_PARAM, Type.FLOAT, StdTypeList.EMPTY,
"move-param-float");
/** <code>r,param(x): double :: r = param(x);</code> */
public static final Rop MOVE_PARAM_DOUBLE =
new Rop(RegOps.MOVE_PARAM, Type.DOUBLE, StdTypeList.EMPTY,
"move-param-double");
/** <code>r,param(x): Object :: r = param(x);</code> */
public static final Rop MOVE_PARAM_OBJECT =
new Rop(RegOps.MOVE_PARAM, Type.OBJECT, StdTypeList.EMPTY,
"move-param-object");
/** <code>r, literal: int :: r = literal;</code> */
public static final Rop CONST_INT =
new Rop(RegOps.CONST, Type.INT, StdTypeList.EMPTY, "const-int");
/** <code>r, literal: long :: r = literal;</code> */
public static final Rop CONST_LONG =
new Rop(RegOps.CONST, Type.LONG, StdTypeList.EMPTY, "const-long");
/** <code>r, literal: float :: r = literal;</code> */
public static final Rop CONST_FLOAT =
new Rop(RegOps.CONST, Type.FLOAT, StdTypeList.EMPTY, "const-float");
/** <code>r, literal: double :: r = literal;</code> */
public static final Rop CONST_DOUBLE =
new Rop(RegOps.CONST, Type.DOUBLE, StdTypeList.EMPTY, "const-double");
/** <code>r, literal: Object :: r = literal;</code> */
public static final Rop CONST_OBJECT =
new Rop(RegOps.CONST, Type.OBJECT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "const-object");
/** <code>r, literal: Object :: r = literal;</code> */
public static final Rop CONST_OBJECT_NOTHROW =
new Rop(RegOps.CONST, Type.OBJECT, StdTypeList.EMPTY,
"const-object-nothrow");
/** <code>goto <i>label</i></code> */
public static final Rop GOTO =
new Rop(RegOps.GOTO, Type.VOID, StdTypeList.EMPTY, Rop.BRANCH_GOTO,
"goto");
/** <code>x: int :: if (x == 0) goto <i>label</i></code> */
public static final Rop IF_EQZ_INT =
new Rop(RegOps.IF_EQ, Type.VOID, StdTypeList.INT, Rop.BRANCH_IF,
"if-eqz-int");
/** <code>x: int :: if (x != 0) goto <i>label</i></code> */
public static final Rop IF_NEZ_INT =
new Rop(RegOps.IF_NE, Type.VOID, StdTypeList.INT, Rop.BRANCH_IF,
"if-nez-int");
/** <code>x: int :: if (x < 0) goto <i>label</i></code> */
public static final Rop IF_LTZ_INT =
new Rop(RegOps.IF_LT, Type.VOID, StdTypeList.INT, Rop.BRANCH_IF,
"if-ltz-int");
/** <code>x: int :: if (x >= 0) goto <i>label</i></code> */
public static final Rop IF_GEZ_INT =
new Rop(RegOps.IF_GE, Type.VOID, StdTypeList.INT, Rop.BRANCH_IF,
"if-gez-int");
/** <code>x: int :: if (x <= 0) goto <i>label</i></code> */
public static final Rop IF_LEZ_INT =
new Rop(RegOps.IF_LE, Type.VOID, StdTypeList.INT, Rop.BRANCH_IF,
"if-lez-int");
/** <code>x: int :: if (x > 0) goto <i>label</i></code> */
public static final Rop IF_GTZ_INT =
new Rop(RegOps.IF_GT, Type.VOID, StdTypeList.INT, Rop.BRANCH_IF,
"if-gtz-int");
/** <code>x: Object :: if (x == null) goto <i>label</i></code> */
public static final Rop IF_EQZ_OBJECT =
new Rop(RegOps.IF_EQ, Type.VOID, StdTypeList.OBJECT, Rop.BRANCH_IF,
"if-eqz-object");
/** <code>x: Object :: if (x != null) goto <i>label</i></code> */
public static final Rop IF_NEZ_OBJECT =
new Rop(RegOps.IF_NE, Type.VOID, StdTypeList.OBJECT, Rop.BRANCH_IF,
"if-nez-object");
/** <code>x,y: int :: if (x == y) goto <i>label</i></code> */
public static final Rop IF_EQ_INT =
new Rop(RegOps.IF_EQ, Type.VOID, StdTypeList.INT_INT, Rop.BRANCH_IF,
"if-eq-int");
/** <code>x,y: int :: if (x != y) goto <i>label</i></code> */
public static final Rop IF_NE_INT =
new Rop(RegOps.IF_NE, Type.VOID, StdTypeList.INT_INT, Rop.BRANCH_IF,
"if-ne-int");
/** <code>x,y: int :: if (x < y) goto <i>label</i></code> */
public static final Rop IF_LT_INT =
new Rop(RegOps.IF_LT, Type.VOID, StdTypeList.INT_INT, Rop.BRANCH_IF,
"if-lt-int");
/** <code>x,y: int :: if (x >= y) goto <i>label</i></code> */
public static final Rop IF_GE_INT =
new Rop(RegOps.IF_GE, Type.VOID, StdTypeList.INT_INT, Rop.BRANCH_IF,
"if-ge-int");
/** <code>x,y: int :: if (x <= y) goto <i>label</i></code> */
public static final Rop IF_LE_INT =
new Rop(RegOps.IF_LE, Type.VOID, StdTypeList.INT_INT, Rop.BRANCH_IF,
"if-le-int");
/** <code>x,y: int :: if (x > y) goto <i>label</i></code> */
public static final Rop IF_GT_INT =
new Rop(RegOps.IF_GT, Type.VOID, StdTypeList.INT_INT, Rop.BRANCH_IF,
"if-gt-int");
/** <code>x,y: Object :: if (x == y) goto <i>label</i></code> */
public static final Rop IF_EQ_OBJECT =
new Rop(RegOps.IF_EQ, Type.VOID, StdTypeList.OBJECT_OBJECT,
Rop.BRANCH_IF, "if-eq-object");
/** <code>x,y: Object :: if (x != y) goto <i>label</i></code> */
public static final Rop IF_NE_OBJECT =
new Rop(RegOps.IF_NE, Type.VOID, StdTypeList.OBJECT_OBJECT,
Rop.BRANCH_IF, "if-ne-object");
/** <code>x: int :: goto switchtable[x]</code> */
public static final Rop SWITCH =
new Rop(RegOps.SWITCH, Type.VOID, StdTypeList.INT, Rop.BRANCH_SWITCH,
"switch");
/** <code>r,x,y: int :: r = x + y;</code> */
public static final Rop ADD_INT =
new Rop(RegOps.ADD, Type.INT, StdTypeList.INT_INT, "add-int");
/** <code>r,x,y: long :: r = x + y;</code> */
public static final Rop ADD_LONG =
new Rop(RegOps.ADD, Type.LONG, StdTypeList.LONG_LONG, "add-long");
/** <code>r,x,y: float :: r = x + y;</code> */
public static final Rop ADD_FLOAT =
new Rop(RegOps.ADD, Type.FLOAT, StdTypeList.FLOAT_FLOAT, "add-float");
/** <code>r,x,y: double :: r = x + y;</code> */
public static final Rop ADD_DOUBLE =
new Rop(RegOps.ADD, Type.DOUBLE, StdTypeList.DOUBLE_DOUBLE,
Rop.BRANCH_NONE, "add-double");
/** <code>r,x,y: int :: r = x - y;</code> */
public static final Rop SUB_INT =
new Rop(RegOps.SUB, Type.INT, StdTypeList.INT_INT, "sub-int");
/** <code>r,x,y: long :: r = x - y;</code> */
public static final Rop SUB_LONG =
new Rop(RegOps.SUB, Type.LONG, StdTypeList.LONG_LONG, "sub-long");
/** <code>r,x,y: float :: r = x - y;</code> */
public static final Rop SUB_FLOAT =
new Rop(RegOps.SUB, Type.FLOAT, StdTypeList.FLOAT_FLOAT, "sub-float");
/** <code>r,x,y: double :: r = x - y;</code> */
public static final Rop SUB_DOUBLE =
new Rop(RegOps.SUB, Type.DOUBLE, StdTypeList.DOUBLE_DOUBLE,
Rop.BRANCH_NONE, "sub-double");
/** <code>r,x,y: int :: r = x * y;</code> */
public static final Rop MUL_INT =
new Rop(RegOps.MUL, Type.INT, StdTypeList.INT_INT, "mul-int");
/** <code>r,x,y: long :: r = x * y;</code> */
public static final Rop MUL_LONG =
new Rop(RegOps.MUL, Type.LONG, StdTypeList.LONG_LONG, "mul-long");
/** <code>r,x,y: float :: r = x * y;</code> */
public static final Rop MUL_FLOAT =
new Rop(RegOps.MUL, Type.FLOAT, StdTypeList.FLOAT_FLOAT, "mul-float");
/** <code>r,x,y: double :: r = x * y;</code> */
public static final Rop MUL_DOUBLE =
new Rop(RegOps.MUL, Type.DOUBLE, StdTypeList.DOUBLE_DOUBLE,
Rop.BRANCH_NONE, "mul-double");
/** <code>r,x,y: int :: r = x / y;</code> */
public static final Rop DIV_INT =
new Rop(RegOps.DIV, Type.INT, StdTypeList.INT_INT,
Exceptions.LIST_Error_ArithmeticException, "div-int");
/** <code>r,x,y: long :: r = x / y;</code> */
public static final Rop DIV_LONG =
new Rop(RegOps.DIV, Type.LONG, StdTypeList.LONG_LONG,
Exceptions.LIST_Error_ArithmeticException, "div-long");
/** <code>r,x,y: float :: r = x / y;</code> */
public static final Rop DIV_FLOAT =
new Rop(RegOps.DIV, Type.FLOAT, StdTypeList.FLOAT_FLOAT, "div-float");
/** <code>r,x,y: double :: r = x / y;</code> */
public static final Rop DIV_DOUBLE =
new Rop(RegOps.DIV, Type.DOUBLE, StdTypeList.DOUBLE_DOUBLE,
"div-double");
/** <code>r,x,y: int :: r = x % y;</code> */
public static final Rop REM_INT =
new Rop(RegOps.REM, Type.INT, StdTypeList.INT_INT,
Exceptions.LIST_Error_ArithmeticException, "rem-int");
/** <code>r,x,y: long :: r = x % y;</code> */
public static final Rop REM_LONG =
new Rop(RegOps.REM, Type.LONG, StdTypeList.LONG_LONG,
Exceptions.LIST_Error_ArithmeticException, "rem-long");
/** <code>r,x,y: float :: r = x % y;</code> */
public static final Rop REM_FLOAT =
new Rop(RegOps.REM, Type.FLOAT, StdTypeList.FLOAT_FLOAT, "rem-float");
/** <code>r,x,y: double :: r = x % y;</code> */
public static final Rop REM_DOUBLE =
new Rop(RegOps.REM, Type.DOUBLE, StdTypeList.DOUBLE_DOUBLE,
"rem-double");
/** <code>r,x: int :: r = -x;</code> */
public static final Rop NEG_INT =
new Rop(RegOps.NEG, Type.INT, StdTypeList.INT, "neg-int");
/** <code>r,x: long :: r = -x;</code> */
public static final Rop NEG_LONG =
new Rop(RegOps.NEG, Type.LONG, StdTypeList.LONG, "neg-long");
/** <code>r,x: float :: r = -x;</code> */
public static final Rop NEG_FLOAT =
new Rop(RegOps.NEG, Type.FLOAT, StdTypeList.FLOAT, "neg-float");
/** <code>r,x: double :: r = -x;</code> */
public static final Rop NEG_DOUBLE =
new Rop(RegOps.NEG, Type.DOUBLE, StdTypeList.DOUBLE, "neg-double");
/** <code>r,x,y: int :: r = x & y;</code> */
public static final Rop AND_INT =
new Rop(RegOps.AND, Type.INT, StdTypeList.INT_INT, "and-int");
/** <code>r,x,y: long :: r = x & y;</code> */
public static final Rop AND_LONG =
new Rop(RegOps.AND, Type.LONG, StdTypeList.LONG_LONG, "and-long");
/** <code>r,x,y: int :: r = x | y;</code> */
public static final Rop OR_INT =
new Rop(RegOps.OR, Type.INT, StdTypeList.INT_INT, "or-int");
/** <code>r,x,y: long :: r = x | y;</code> */
public static final Rop OR_LONG =
new Rop(RegOps.OR, Type.LONG, StdTypeList.LONG_LONG, "or-long");
/** <code>r,x,y: int :: r = x ^ y;</code> */
public static final Rop XOR_INT =
new Rop(RegOps.XOR, Type.INT, StdTypeList.INT_INT, "xor-int");
/** <code>r,x,y: long :: r = x ^ y;</code> */
public static final Rop XOR_LONG =
new Rop(RegOps.XOR, Type.LONG, StdTypeList.LONG_LONG, "xor-long");
/** <code>r,x,y: int :: r = x << y;</code> */
public static final Rop SHL_INT =
new Rop(RegOps.SHL, Type.INT, StdTypeList.INT_INT, "shl-int");
/** <code>r,x: long; y: int :: r = x << y;</code> */
public static final Rop SHL_LONG =
new Rop(RegOps.SHL, Type.LONG, StdTypeList.LONG_INT, "shl-long");
/** <code>r,x,y: int :: r = x >> y;</code> */
public static final Rop SHR_INT =
new Rop(RegOps.SHR, Type.INT, StdTypeList.INT_INT, "shr-int");
/** <code>r,x: long; y: int :: r = x >> y;</code> */
public static final Rop SHR_LONG =
new Rop(RegOps.SHR, Type.LONG, StdTypeList.LONG_INT, "shr-long");
/** <code>r,x,y: int :: r = x >>> y;</code> */
public static final Rop USHR_INT =
new Rop(RegOps.USHR, Type.INT, StdTypeList.INT_INT, "ushr-int");
/** <code>r,x: long; y: int :: r = x >>> y;</code> */
public static final Rop USHR_LONG =
new Rop(RegOps.USHR, Type.LONG, StdTypeList.LONG_INT, "ushr-long");
/** <code>r,x: int :: r = ~x;</code> */
public static final Rop NOT_INT =
new Rop(RegOps.NOT, Type.INT, StdTypeList.INT, "not-int");
/** <code>r,x: long :: r = ~x;</code> */
public static final Rop NOT_LONG =
new Rop(RegOps.NOT, Type.LONG, StdTypeList.LONG, "not-long");
/** <code>r,x,c: int :: r = x + c;</code> */
public static final Rop ADD_CONST_INT =
new Rop(RegOps.ADD, Type.INT, StdTypeList.INT, "add-const-int");
/** <code>r,x,c: long :: r = x + c;</code> */
public static final Rop ADD_CONST_LONG =
new Rop(RegOps.ADD, Type.LONG, StdTypeList.LONG, "add-const-long");
/** <code>r,x,c: float :: r = x + c;</code> */
public static final Rop ADD_CONST_FLOAT =
new Rop(RegOps.ADD, Type.FLOAT, StdTypeList.FLOAT, "add-const-float");
/** <code>r,x,c: double :: r = x + c;</code> */
public static final Rop ADD_CONST_DOUBLE =
new Rop(RegOps.ADD, Type.DOUBLE, StdTypeList.DOUBLE,
"add-const-double");
/** <code>r,x,c: int :: r = x - c;</code> */
public static final Rop SUB_CONST_INT =
new Rop(RegOps.SUB, Type.INT, StdTypeList.INT, "sub-const-int");
/** <code>r,x,c: long :: r = x - c;</code> */
public static final Rop SUB_CONST_LONG =
new Rop(RegOps.SUB, Type.LONG, StdTypeList.LONG, "sub-const-long");
/** <code>r,x,c: float :: r = x - c;</code> */
public static final Rop SUB_CONST_FLOAT =
new Rop(RegOps.SUB, Type.FLOAT, StdTypeList.FLOAT, "sub-const-float");
/** <code>r,x,c: double :: r = x - c;</code> */
public static final Rop SUB_CONST_DOUBLE =
new Rop(RegOps.SUB, Type.DOUBLE, StdTypeList.DOUBLE,
"sub-const-double");
/** <code>r,x,c: int :: r = x * c;</code> */
public static final Rop MUL_CONST_INT =
new Rop(RegOps.MUL, Type.INT, StdTypeList.INT, "mul-const-int");
/** <code>r,x,c: long :: r = x * c;</code> */
public static final Rop MUL_CONST_LONG =
new Rop(RegOps.MUL, Type.LONG, StdTypeList.LONG, "mul-const-long");
/** <code>r,x,c: float :: r = x * c;</code> */
public static final Rop MUL_CONST_FLOAT =
new Rop(RegOps.MUL, Type.FLOAT, StdTypeList.FLOAT, "mul-const-float");
/** <code>r,x,c: double :: r = x * c;</code> */
public static final Rop MUL_CONST_DOUBLE =
new Rop(RegOps.MUL, Type.DOUBLE, StdTypeList.DOUBLE,
"mul-const-double");
/** <code>r,x,c: int :: r = x / c;</code> */
public static final Rop DIV_CONST_INT =
new Rop(RegOps.DIV, Type.INT, StdTypeList.INT,
Exceptions.LIST_Error_ArithmeticException, "div-const-int");
/** <code>r,x,c: long :: r = x / c;</code> */
public static final Rop DIV_CONST_LONG =
new Rop(RegOps.DIV, Type.LONG, StdTypeList.LONG,
Exceptions.LIST_Error_ArithmeticException, "div-const-long");
/** <code>r,x,c: float :: r = x / c;</code> */
public static final Rop DIV_CONST_FLOAT =
new Rop(RegOps.DIV, Type.FLOAT, StdTypeList.FLOAT, "div-const-float");
/** <code>r,x,c: double :: r = x / c;</code> */
public static final Rop DIV_CONST_DOUBLE =
new Rop(RegOps.DIV, Type.DOUBLE, StdTypeList.DOUBLE,
"div-const-double");
/** <code>r,x,c: int :: r = x % c;</code> */
public static final Rop REM_CONST_INT =
new Rop(RegOps.REM, Type.INT, StdTypeList.INT,
Exceptions.LIST_Error_ArithmeticException, "rem-const-int");
/** <code>r,x,c: long :: r = x % c;</code> */
public static final Rop REM_CONST_LONG =
new Rop(RegOps.REM, Type.LONG, StdTypeList.LONG,
Exceptions.LIST_Error_ArithmeticException, "rem-const-long");
/** <code>r,x,c: float :: r = x % c;</code> */
public static final Rop REM_CONST_FLOAT =
new Rop(RegOps.REM, Type.FLOAT, StdTypeList.FLOAT, "rem-const-float");
/** <code>r,x,c: double :: r = x % c;</code> */
public static final Rop REM_CONST_DOUBLE =
new Rop(RegOps.REM, Type.DOUBLE, StdTypeList.DOUBLE,
"rem-const-double");
/** <code>r,x,c: int :: r = x & c;</code> */
public static final Rop AND_CONST_INT =
new Rop(RegOps.AND, Type.INT, StdTypeList.INT, "and-const-int");
/** <code>r,x,c: long :: r = x & c;</code> */
public static final Rop AND_CONST_LONG =
new Rop(RegOps.AND, Type.LONG, StdTypeList.LONG, "and-const-long");
/** <code>r,x,c: int :: r = x | c;</code> */
public static final Rop OR_CONST_INT =
new Rop(RegOps.OR, Type.INT, StdTypeList.INT, "or-const-int");
/** <code>r,x,c: long :: r = x | c;</code> */
public static final Rop OR_CONST_LONG =
new Rop(RegOps.OR, Type.LONG, StdTypeList.LONG, "or-const-long");
/** <code>r,x,c: int :: r = x ^ c;</code> */
public static final Rop XOR_CONST_INT =
new Rop(RegOps.XOR, Type.INT, StdTypeList.INT, "xor-const-int");
/** <code>r,x,c: long :: r = x ^ c;</code> */
public static final Rop XOR_CONST_LONG =
new Rop(RegOps.XOR, Type.LONG, StdTypeList.LONG, "xor-const-long");
/** <code>r,x,c: int :: r = x << c;</code> */
public static final Rop SHL_CONST_INT =
new Rop(RegOps.SHL, Type.INT, StdTypeList.INT, "shl-const-int");
/** <code>r,x: long; c: int :: r = x << c;</code> */
public static final Rop SHL_CONST_LONG =
new Rop(RegOps.SHL, Type.LONG, StdTypeList.INT, "shl-const-long");
/** <code>r,x,c: int :: r = x >> c;</code> */
public static final Rop SHR_CONST_INT =
new Rop(RegOps.SHR, Type.INT, StdTypeList.INT, "shr-const-int");
/** <code>r,x: long; c: int :: r = x >> c;</code> */
public static final Rop SHR_CONST_LONG =
new Rop(RegOps.SHR, Type.LONG, StdTypeList.INT, "shr-const-long");
/** <code>r,x,c: int :: r = x >>> c;</code> */
public static final Rop USHR_CONST_INT =
new Rop(RegOps.USHR, Type.INT, StdTypeList.INT, "ushr-const-int");
/** <code>r,x: long; c: int :: r = x >>> c;</code> */
public static final Rop USHR_CONST_LONG =
new Rop(RegOps.USHR, Type.LONG, StdTypeList.INT, "ushr-const-long");
/** <code>r: int; x,y: long :: r = cmp(x, y);</code> */
public static final Rop CMPL_LONG =
new Rop(RegOps.CMPL, Type.INT, StdTypeList.LONG_LONG, "cmpl-long");
/** <code>r: int; x,y: float :: r = cmpl(x, y);</code> */
public static final Rop CMPL_FLOAT =
new Rop(RegOps.CMPL, Type.INT, StdTypeList.FLOAT_FLOAT, "cmpl-float");
/** <code>r: int; x,y: double :: r = cmpl(x, y);</code> */
public static final Rop CMPL_DOUBLE =
new Rop(RegOps.CMPL, Type.INT, StdTypeList.DOUBLE_DOUBLE,
"cmpl-double");
/** <code>r: int; x,y: float :: r = cmpg(x, y);</code> */
public static final Rop CMPG_FLOAT =
new Rop(RegOps.CMPG, Type.INT, StdTypeList.FLOAT_FLOAT, "cmpg-float");
/** <code>r: int; x,y: double :: r = cmpg(x, y);</code> */
public static final Rop CMPG_DOUBLE =
new Rop(RegOps.CMPG, Type.INT, StdTypeList.DOUBLE_DOUBLE,
"cmpg-double");
/** <code>r: int; x: long :: r = (int) x</code> */
public static final Rop CONV_L2I =
new Rop(RegOps.CONV, Type.INT, StdTypeList.LONG, "conv-l2i");
/** <code>r: int; x: float :: r = (int) x</code> */
public static final Rop CONV_F2I =
new Rop(RegOps.CONV, Type.INT, StdTypeList.FLOAT, "conv-f2i");
/** <code>r: int; x: double :: r = (int) x</code> */
public static final Rop CONV_D2I =
new Rop(RegOps.CONV, Type.INT, StdTypeList.DOUBLE, "conv-d2i");
/** <code>r: long; x: int :: r = (long) x</code> */
public static final Rop CONV_I2L =
new Rop(RegOps.CONV, Type.LONG, StdTypeList.INT, "conv-i2l");
/** <code>r: long; x: float :: r = (long) x</code> */
public static final Rop CONV_F2L =
new Rop(RegOps.CONV, Type.LONG, StdTypeList.FLOAT, "conv-f2l");
/** <code>r: long; x: double :: r = (long) x</code> */
public static final Rop CONV_D2L =
new Rop(RegOps.CONV, Type.LONG, StdTypeList.DOUBLE, "conv-d2l");
/** <code>r: float; x: int :: r = (float) x</code> */
public static final Rop CONV_I2F =
new Rop(RegOps.CONV, Type.FLOAT, StdTypeList.INT, "conv-i2f");
/** <code>r: float; x: long :: r = (float) x</code> */
public static final Rop CONV_L2F =
new Rop(RegOps.CONV, Type.FLOAT, StdTypeList.LONG, "conv-l2f");
/** <code>r: float; x: double :: r = (float) x</code> */
public static final Rop CONV_D2F =
new Rop(RegOps.CONV, Type.FLOAT, StdTypeList.DOUBLE, "conv-d2f");
/** <code>r: double; x: int :: r = (double) x</code> */
public static final Rop CONV_I2D =
new Rop(RegOps.CONV, Type.DOUBLE, StdTypeList.INT, "conv-i2d");
/** <code>r: double; x: long :: r = (double) x</code> */
public static final Rop CONV_L2D =
new Rop(RegOps.CONV, Type.DOUBLE, StdTypeList.LONG, "conv-l2d");
/** <code>r: double; x: float :: r = (double) x</code> */
public static final Rop CONV_F2D =
new Rop(RegOps.CONV, Type.DOUBLE, StdTypeList.FLOAT, "conv-f2d");
/**
* <code>r,x: int :: r = (x << 24) >> 24</code> (Java-style
* convert int to byte)
*/
public static final Rop TO_BYTE =
new Rop(RegOps.TO_BYTE, Type.INT, StdTypeList.INT, "to-byte");
/**
* <code>r,x: int :: r = x & 0xffff</code> (Java-style
* convert int to char)
*/
public static final Rop TO_CHAR =
new Rop(RegOps.TO_CHAR, Type.INT, StdTypeList.INT, "to-char");
/**
* <code>r,x: int :: r = (x << 16) >> 16</code> (Java-style
* convert int to short)
*/
public static final Rop TO_SHORT =
new Rop(RegOps.TO_SHORT, Type.INT, StdTypeList.INT, "to-short");
/** <code>return void</code> */
public static final Rop RETURN_VOID =
new Rop(RegOps.RETURN, Type.VOID, StdTypeList.EMPTY, Rop.BRANCH_RETURN,
"return-void");
/** <code>x: int; return x</code> */
public static final Rop RETURN_INT =
new Rop(RegOps.RETURN, Type.VOID, StdTypeList.INT, Rop.BRANCH_RETURN,
"return-int");
/** <code>x: long; return x</code> */
public static final Rop RETURN_LONG =
new Rop(RegOps.RETURN, Type.VOID, StdTypeList.LONG, Rop.BRANCH_RETURN,
"return-long");
/** <code>x: float; return x</code> */
public static final Rop RETURN_FLOAT =
new Rop(RegOps.RETURN, Type.VOID, StdTypeList.FLOAT, Rop.BRANCH_RETURN,
"return-float");
/** <code>x: double; return x</code> */
public static final Rop RETURN_DOUBLE =
new Rop(RegOps.RETURN, Type.VOID, StdTypeList.DOUBLE,
Rop.BRANCH_RETURN, "return-double");
/** <code>x: Object; return x</code> */
public static final Rop RETURN_OBJECT =
new Rop(RegOps.RETURN, Type.VOID, StdTypeList.OBJECT,
Rop.BRANCH_RETURN, "return-object");
/** <code>T: any type; r: int; x: T[]; :: r = x.length</code> */
public static final Rop ARRAY_LENGTH =
new Rop(RegOps.ARRAY_LENGTH, Type.INT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException, "array-length");
/** <code>x: Throwable :: throw(x)</code> */
public static final Rop THROW =
new Rop(RegOps.THROW, Type.VOID, StdTypeList.THROWABLE,
StdTypeList.THROWABLE, "throw");
/** <code>x: Object :: monitorenter(x)</code> */
public static final Rop MONITOR_ENTER =
new Rop(RegOps.MONITOR_ENTER, Type.VOID, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException, "monitor-enter");
/** <code>x: Object :: monitorexit(x)</code> */
public static final Rop MONITOR_EXIT =
new Rop(RegOps.MONITOR_EXIT, Type.VOID, StdTypeList.OBJECT,
Exceptions.LIST_Error_Null_IllegalMonitorStateException,
"monitor-exit");
/** <code>r,y: int; x: int[] :: r = x[y]</code> */
public static final Rop AGET_INT =
new Rop(RegOps.AGET, Type.INT, StdTypeList.INTARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aget-int");
/** <code>r: long; x: long[]; y: int :: r = x[y]</code> */
public static final Rop AGET_LONG =
new Rop(RegOps.AGET, Type.LONG, StdTypeList.LONGARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aget-long");
/** <code>r: float; x: float[]; y: int :: r = x[y]</code> */
public static final Rop AGET_FLOAT =
new Rop(RegOps.AGET, Type.FLOAT, StdTypeList.FLOATARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aget-float");
/** <code>r: double; x: double[]; y: int :: r = x[y]</code> */
public static final Rop AGET_DOUBLE =
new Rop(RegOps.AGET, Type.DOUBLE, StdTypeList.DOUBLEARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aget-double");
/** <code>r: Object; x: Object[]; y: int :: r = x[y]</code> */
public static final Rop AGET_OBJECT =
new Rop(RegOps.AGET, Type.OBJECT, StdTypeList.OBJECTARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aget-object");
/** <code>r: boolean; x: boolean[]; y: int :: r = x[y]</code> */
public static final Rop AGET_BOOLEAN =
new Rop(RegOps.AGET, Type.INT, StdTypeList.BOOLEANARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aget-boolean");
/** <code>r: byte; x: byte[]; y: int :: r = x[y]</code> */
public static final Rop AGET_BYTE =
new Rop(RegOps.AGET, Type.INT, StdTypeList.BYTEARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds, "aget-byte");
/** <code>r: char; x: char[]; y: int :: r = x[y]</code> */
public static final Rop AGET_CHAR =
new Rop(RegOps.AGET, Type.INT, StdTypeList.CHARARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds, "aget-char");
/** <code>r: short; x: short[]; y: int :: r = x[y]</code> */
public static final Rop AGET_SHORT =
new Rop(RegOps.AGET, Type.INT, StdTypeList.SHORTARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aget-short");
/** <code>x,z: int; y: int[] :: y[z] = x</code> */
public static final Rop APUT_INT =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.INT_INTARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds, "aput-int");
/** <code>x: long; y: long[]; z: int :: y[z] = x</code> */
public static final Rop APUT_LONG =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.LONG_LONGARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds, "aput-long");
/** <code>x: float; y: float[]; z: int :: y[z] = x</code> */
public static final Rop APUT_FLOAT =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.FLOAT_FLOATARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aput-float");
/** <code>x: double; y: double[]; z: int :: y[z] = x</code> */
public static final Rop APUT_DOUBLE =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.DOUBLE_DOUBLEARR_INT,
Exceptions.LIST_Error_Null_ArrayIndexOutOfBounds,
"aput-double");
/** <code>x: Object; y: Object[]; z: int :: y[z] = x</code> */
public static final Rop APUT_OBJECT =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.OBJECT_OBJECTARR_INT,
Exceptions.LIST_Error_Null_ArrayIndex_ArrayStore,
"aput-object");
/** <code>x: boolean; y: boolean[]; z: int :: y[z] = x</code> */
public static final Rop APUT_BOOLEAN =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.INT_BOOLEANARR_INT,
Exceptions.LIST_Error_Null_ArrayIndex_ArrayStore,
"aput-boolean");
/** <code>x: byte; y: byte[]; z: int :: y[z] = x</code> */
public static final Rop APUT_BYTE =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.INT_BYTEARR_INT,
Exceptions.LIST_Error_Null_ArrayIndex_ArrayStore, "aput-byte");
/** <code>x: char; y: char[]; z: int :: y[z] = x</code> */
public static final Rop APUT_CHAR =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.INT_CHARARR_INT,
Exceptions.LIST_Error_Null_ArrayIndex_ArrayStore, "aput-char");
/** <code>x: short; y: short[]; z: int :: y[z] = x</code> */
public static final Rop APUT_SHORT =
new Rop(RegOps.APUT, Type.VOID, StdTypeList.INT_SHORTARR_INT,
Exceptions.LIST_Error_Null_ArrayIndex_ArrayStore,
"aput-short");
/**
* <code>T: any non-array object type :: r =
* alloc(T)</code> (allocate heap space for an object)
*/
public static final Rop NEW_INSTANCE =
new Rop(RegOps.NEW_INSTANCE, Type.OBJECT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "new-instance");
/** <code>r: int[]; x: int :: r = new int[x]</code> */
public static final Rop NEW_ARRAY_INT =
new Rop(RegOps.NEW_ARRAY, Type.INT_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-int");
/** <code>r: long[]; x: int :: r = new long[x]</code> */
public static final Rop NEW_ARRAY_LONG =
new Rop(RegOps.NEW_ARRAY, Type.LONG_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-long");
/** <code>r: float[]; x: int :: r = new float[x]</code> */
public static final Rop NEW_ARRAY_FLOAT =
new Rop(RegOps.NEW_ARRAY, Type.FLOAT_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-float");
/** <code>r: double[]; x: int :: r = new double[x]</code> */
public static final Rop NEW_ARRAY_DOUBLE =
new Rop(RegOps.NEW_ARRAY, Type.DOUBLE_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-double");
/** <code>r: boolean[]; x: int :: r = new boolean[x]</code> */
public static final Rop NEW_ARRAY_BOOLEAN =
new Rop(RegOps.NEW_ARRAY, Type.BOOLEAN_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-boolean");
/** <code>r: byte[]; x: int :: r = new byte[x]</code> */
public static final Rop NEW_ARRAY_BYTE =
new Rop(RegOps.NEW_ARRAY, Type.BYTE_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-byte");
/** <code>r: char[]; x: int :: r = new char[x]</code> */
public static final Rop NEW_ARRAY_CHAR =
new Rop(RegOps.NEW_ARRAY, Type.CHAR_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-char");
/** <code>r: short[]; x: int :: r = new short[x]</code> */
public static final Rop NEW_ARRAY_SHORT =
new Rop(RegOps.NEW_ARRAY, Type.SHORT_ARRAY, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-short");
/**
* <code>T: any non-array object type; x: Object :: (T) x</code> (can
* throw <code>ClassCastException</code>)
*/
public static final Rop CHECK_CAST =
new Rop(RegOps.CHECK_CAST, Type.VOID, StdTypeList.OBJECT,
Exceptions.LIST_Error_ClassCastException, "check-cast");
/**
* <code>T: any non-array object type; x: Object :: x instanceof
* T</code>. Note: This is listed as throwing <code>Error</code>
* explicitly because the op <i>can</i> throw, but there are no
* other predefined exceptions for it.
*/
public static final Rop INSTANCE_OF =
new Rop(RegOps.INSTANCE_OF, Type.INT, StdTypeList.OBJECT,
Exceptions.LIST_Error, "instance-of");
/**
* <code>r: int; x: Object; f: instance field spec of
* type int :: r = x.f</code>
*/
public static final Rop GET_FIELD_INT =
new Rop(RegOps.GET_FIELD, Type.INT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException, "get-field-int");
/**
* <code>r: long; x: Object; f: instance field spec of
* type long :: r = x.f</code>
*/
public static final Rop GET_FIELD_LONG =
new Rop(RegOps.GET_FIELD, Type.LONG, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException, "get-field-long");
/**
* <code>r: float; x: Object; f: instance field spec of
* type float :: r = x.f</code>
*/
public static final Rop GET_FIELD_FLOAT =
new Rop(RegOps.GET_FIELD, Type.FLOAT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException,
"get-field-float");
/**
* <code>r: double; x: Object; f: instance field spec of
* type double :: r = x.f</code>
*/
public static final Rop GET_FIELD_DOUBLE =
new Rop(RegOps.GET_FIELD, Type.DOUBLE, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException,
"get-field-double");
/**
* <code>r: Object; x: Object; f: instance field spec of
* type Object :: r = x.f</code>
*/
public static final Rop GET_FIELD_OBJECT =
new Rop(RegOps.GET_FIELD, Type.OBJECT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException,
"get-field-object");
/**
* <code>r: boolean; x: Object; f: instance field spec of
* type boolean :: r = x.f</code>
*/
public static final Rop GET_FIELD_BOOLEAN =
new Rop(RegOps.GET_FIELD, Type.INT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException,
"get-field-boolean");
/**
* <code>r: byte; x: Object; f: instance field spec of
* type byte :: r = x.f</code>
*/
public static final Rop GET_FIELD_BYTE =
new Rop(RegOps.GET_FIELD, Type.INT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException,
"get-field-byte");
/**
* <code>r: char; x: Object; f: instance field spec of
* type char :: r = x.f</code>
*/
public static final Rop GET_FIELD_CHAR =
new Rop(RegOps.GET_FIELD, Type.INT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException,
"get-field-char");
/**
* <code>r: short; x: Object; f: instance field spec of
* type short :: r = x.f</code>
*/
public static final Rop GET_FIELD_SHORT =
new Rop(RegOps.GET_FIELD, Type.INT, StdTypeList.OBJECT,
Exceptions.LIST_Error_NullPointerException,
"get-field-short");
/**
* <code>r: int; f: static field spec of type int :: r =
* f</code>
*/
public static final Rop GET_STATIC_INT =
new Rop(RegOps.GET_STATIC, Type.INT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-static-int");
/**
* <code>r: long; f: static field spec of type long :: r =
* f</code>
*/
public static final Rop GET_STATIC_LONG =
new Rop(RegOps.GET_STATIC, Type.LONG, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-static-long");
/**
* <code>r: float; f: static field spec of type float :: r =
* f</code>
*/
public static final Rop GET_STATIC_FLOAT =
new Rop(RegOps.GET_STATIC, Type.FLOAT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-static-float");
/**
* <code>r: double; f: static field spec of type double :: r =
* f</code>
*/
public static final Rop GET_STATIC_DOUBLE =
new Rop(RegOps.GET_STATIC, Type.DOUBLE, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-static-double");
/**
* <code>r: Object; f: static field spec of type Object :: r =
* f</code>
*/
public static final Rop GET_STATIC_OBJECT =
new Rop(RegOps.GET_STATIC, Type.OBJECT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-static-object");
/**
* <code>r: boolean; f: static field spec of type boolean :: r =
* f</code>
*/
public static final Rop GET_STATIC_BOOLEAN =
new Rop(RegOps.GET_STATIC, Type.INT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-field-boolean");
/**
* <code>r: byte; f: static field spec of type byte :: r =
* f</code>
*/
public static final Rop GET_STATIC_BYTE =
new Rop(RegOps.GET_STATIC, Type.INT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-field-byte");
/**
* <code>r: char; f: static field spec of type char :: r =
* f</code>
*/
public static final Rop GET_STATIC_CHAR =
new Rop(RegOps.GET_STATIC, Type.INT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-field-char");
/**
* <code>r: short; f: static field spec of type short :: r =
* f</code>
*/
public static final Rop GET_STATIC_SHORT =
new Rop(RegOps.GET_STATIC, Type.INT, StdTypeList.EMPTY,
Exceptions.LIST_Error, "get-field-short");
/**
* <code>x: int; y: Object; f: instance field spec of type
* int :: y.f = x</code>
*/
public static final Rop PUT_FIELD_INT =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.INT_OBJECT,
Exceptions.LIST_Error_NullPointerException, "put-field-int");
/**
* <code>x: long; y: Object; f: instance field spec of type
* long :: y.f = x</code>
*/
public static final Rop PUT_FIELD_LONG =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.LONG_OBJECT,
Exceptions.LIST_Error_NullPointerException, "put-field-long");
/**
* <code>x: float; y: Object; f: instance field spec of type
* float :: y.f = x</code>
*/
public static final Rop PUT_FIELD_FLOAT =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.FLOAT_OBJECT,
Exceptions.LIST_Error_NullPointerException,
"put-field-float");
/**
* <code>x: double; y: Object; f: instance field spec of type
* double :: y.f = x</code>
*/
public static final Rop PUT_FIELD_DOUBLE =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.DOUBLE_OBJECT,
Exceptions.LIST_Error_NullPointerException,
"put-field-double");
/**
* <code>x: Object; y: Object; f: instance field spec of type
* Object :: y.f = x</code>
*/
public static final Rop PUT_FIELD_OBJECT =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.OBJECT_OBJECT,
Exceptions.LIST_Error_NullPointerException,
"put-field-object");
/**
* <code>x: int; y: Object; f: instance field spec of type
* boolean :: y.f = x</code>
*/
public static final Rop PUT_FIELD_BOOLEAN =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.INT_OBJECT,
Exceptions.LIST_Error_NullPointerException,
"put-field-boolean");
/**
* <code>x: int; y: Object; f: instance field spec of type
* byte :: y.f = x</code>
*/
public static final Rop PUT_FIELD_BYTE =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.INT_OBJECT,
Exceptions.LIST_Error_NullPointerException,
"put-field-byte");
/**
* <code>x: int; y: Object; f: instance field spec of type
* char :: y.f = x</code>
*/
public static final Rop PUT_FIELD_CHAR =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.INT_OBJECT,
Exceptions.LIST_Error_NullPointerException,
"put-field-char");
/**
* <code>x: int; y: Object; f: instance field spec of type
* short :: y.f = x</code>
*/
public static final Rop PUT_FIELD_SHORT =
new Rop(RegOps.PUT_FIELD, Type.VOID, StdTypeList.INT_OBJECT,
Exceptions.LIST_Error_NullPointerException,
"put-field-short");
/**
* <code>f: static field spec of type int; x: int :: f =
* x</code>
*/
public static final Rop PUT_STATIC_INT =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.INT,
Exceptions.LIST_Error, "put-static-int");
/**
* <code>f: static field spec of type long; x: long :: f =
* x</code>
*/
public static final Rop PUT_STATIC_LONG =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.LONG,
Exceptions.LIST_Error, "put-static-long");
/**
* <code>f: static field spec of type float; x: float :: f =
* x</code>
*/
public static final Rop PUT_STATIC_FLOAT =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.FLOAT,
Exceptions.LIST_Error, "put-static-float");
/**
* <code>f: static field spec of type double; x: double :: f =
* x</code>
*/
public static final Rop PUT_STATIC_DOUBLE =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.DOUBLE,
Exceptions.LIST_Error, "put-static-double");
/**
* <code>f: static field spec of type Object; x: Object :: f =
* x</code>
*/
public static final Rop PUT_STATIC_OBJECT =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.OBJECT,
Exceptions.LIST_Error, "put-static-object");
/**
* <code>f: static field spec of type boolean; x: boolean :: f =
* x</code>
*/
public static final Rop PUT_STATIC_BOOLEAN =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.INT,
Exceptions.LIST_Error, "put-static-boolean");
/**
* <code>f: static field spec of type byte; x: byte :: f =
* x</code>
*/
public static final Rop PUT_STATIC_BYTE =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.INT,
Exceptions.LIST_Error, "put-static-byte");
/**
* <code>f: static field spec of type char; x: char :: f =
* x</code>
*/
public static final Rop PUT_STATIC_CHAR =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.INT,
Exceptions.LIST_Error, "put-static-char");
/**
* <code>f: static field spec of type short; x: short :: f =
* x</code>
*/
public static final Rop PUT_STATIC_SHORT =
new Rop(RegOps.PUT_STATIC, Type.VOID, StdTypeList.INT,
Exceptions.LIST_Error, "put-static-short");
/** <code>x: Int :: local variable begins in x */
public static final Rop MARK_LOCAL_INT =
new Rop (RegOps.MARK_LOCAL, Type.VOID,
StdTypeList.INT, "mark-local-int");
/** <code>x: Long :: local variable begins in x */
public static final Rop MARK_LOCAL_LONG =
new Rop (RegOps.MARK_LOCAL, Type.VOID,
StdTypeList.LONG, "mark-local-long");
/** <code>x: Float :: local variable begins in x */
public static final Rop MARK_LOCAL_FLOAT =
new Rop (RegOps.MARK_LOCAL, Type.VOID,
StdTypeList.FLOAT, "mark-local-float");
/** <code>x: Double :: local variable begins in x */
public static final Rop MARK_LOCAL_DOUBLE =
new Rop (RegOps.MARK_LOCAL, Type.VOID,
StdTypeList.DOUBLE, "mark-local-double");
/** <code>x: Object :: local variable begins in x */
public static final Rop MARK_LOCAL_OBJECT =
new Rop (RegOps.MARK_LOCAL, Type.VOID,
StdTypeList.OBJECT, "mark-local-object");
/** <code>T: Any primitive type; v0..vx: T :: {v0, ..., vx}</code> */
public static final Rop FILL_ARRAY_DATA =
new Rop(RegOps.FILL_ARRAY_DATA, Type.VOID, StdTypeList.EMPTY,
"fill-array-data");
/**
* Returns the appropriate rop for the given opcode, destination,
* and sources. The result is typically, but not necessarily, a
* shared instance.
*
* <p><b>Note:</b> 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.</p>
*
* @param opcode the opcode
* @param dest non-null; destination type, or {@link Type#VOID} if none
* @param sources non-null; list of source types
* @param cst null-ok; associated constant, if any
* @return non-null; an appropriate instance
*/
public static Rop ropFor(int opcode, TypeBearer dest, TypeList sources,
Constant cst) {
switch (opcode) {
case RegOps.NOP: return NOP;
case RegOps.MOVE: return opMove(dest);
case RegOps.MOVE_PARAM: return opMoveParam(dest);
case RegOps.MOVE_EXCEPTION: return opMoveException(dest);
case RegOps.CONST: return opConst(dest);
case RegOps.GOTO: return GOTO;
case RegOps.IF_EQ: return opIfEq(sources);
case RegOps.IF_NE: return opIfNe(sources);
case RegOps.IF_LT: return opIfLt(sources);
case RegOps.IF_GE: return opIfGe(sources);
case RegOps.IF_LE: return opIfLe(sources);
case RegOps.IF_GT: return opIfGt(sources);
case RegOps.SWITCH: return SWITCH;
case RegOps.ADD: return opAdd(sources);
case RegOps.SUB: return opSub(sources);
case RegOps.MUL: return opMul(sources);
case RegOps.DIV: return opDiv(sources);
case RegOps.REM: return opRem(sources);
case RegOps.NEG: return opNeg(dest);
case RegOps.AND: return opAnd(sources);
case RegOps.OR: return opOr(sources);
case RegOps.XOR: return opXor(sources);
case RegOps.SHL: return opShl(sources);
case RegOps.SHR: return opShr(sources);
case RegOps.USHR: return opUshr(sources);
case RegOps.NOT: return opNot(dest);
case RegOps.CMPL: return opCmpl(sources.getType(0));
case RegOps.CMPG: return opCmpg(sources.getType(0));
case RegOps.CONV: return opConv(dest, sources.getType(0));
case RegOps.TO_BYTE: return TO_BYTE;
case RegOps.TO_CHAR: return TO_CHAR;
case RegOps.TO_SHORT: return TO_SHORT;
case RegOps.RETURN: {
if (sources.size() == 0) {
return RETURN_VOID;
}
return opReturn(sources.getType(0));
}
case RegOps.ARRAY_LENGTH: return ARRAY_LENGTH;
case RegOps.THROW: return THROW;
case RegOps.MONITOR_ENTER: return MONITOR_ENTER;
case RegOps.MONITOR_EXIT: return MONITOR_EXIT;
case RegOps.AGET: {
Type source = sources.getType(0);
if (source == Type.KNOWN_NULL) {
// Treat a known-null as an Object[] in this context.
source = Type.OBJECT_ARRAY;
}
return opAget(source.getComponentType());
}
case RegOps.APUT: {
Type source = sources.getType(1);
if (source == Type.KNOWN_NULL) {
// Treat a known-null as an Object[] in this context.
source = Type.OBJECT_ARRAY;
}
return opAput(source.getComponentType());
}
case RegOps.NEW_INSTANCE: return NEW_INSTANCE;
case RegOps.NEW_ARRAY: return opNewArray(dest.getType());
case RegOps.CHECK_CAST: return CHECK_CAST;
case RegOps.INSTANCE_OF: return INSTANCE_OF;
case RegOps.GET_FIELD: return opGetField(dest);
case RegOps.GET_STATIC: return opGetStatic(dest);
case RegOps.PUT_FIELD: return opPutField(sources.getType(0));
case RegOps.PUT_STATIC: return opPutStatic(sources.getType(0));
case RegOps.INVOKE_STATIC: {
return opInvokeStatic(((CstMethodRef) cst).getPrototype());
}
case RegOps.INVOKE_VIRTUAL: {
CstBaseMethodRef cstMeth = (CstMethodRef) cst;
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeVirtual(meth);
}
case RegOps.INVOKE_SUPER: {
CstBaseMethodRef cstMeth = (CstMethodRef) cst;
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeSuper(meth);
}
case RegOps.INVOKE_DIRECT: {
CstBaseMethodRef cstMeth = (CstMethodRef) cst;
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeDirect(meth);
}
case RegOps.INVOKE_INTERFACE: {
CstBaseMethodRef cstMeth = (CstMethodRef) cst;
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeInterface(meth);
}
}
throw new RuntimeException("unknown opcode " + RegOps.opName(opcode));
}
/**
* Returns the appropriate <code>move</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; type of value being moved
* @return non-null; an appropriate instance
*/
public static Rop opMove(TypeBearer type) {
switch (type.getBasicFrameType()) {
case Type.BT_INT: return MOVE_INT;
case Type.BT_LONG: return MOVE_LONG;
case Type.BT_FLOAT: return MOVE_FLOAT;
case Type.BT_DOUBLE: return MOVE_DOUBLE;
case Type.BT_OBJECT: return MOVE_OBJECT;
case Type.BT_ADDR: return MOVE_RETURN_ADDRESS;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>move-param</code> rop for the
* given type. The result is a shared instance.
*
* @param type non-null; type of value being moved
* @return non-null; an appropriate instance
*/
public static Rop opMoveParam(TypeBearer type) {
switch (type.getBasicFrameType()) {
case Type.BT_INT: return MOVE_PARAM_INT;
case Type.BT_LONG: return MOVE_PARAM_LONG;
case Type.BT_FLOAT: return MOVE_PARAM_FLOAT;
case Type.BT_DOUBLE: return MOVE_PARAM_DOUBLE;
case Type.BT_OBJECT: return MOVE_PARAM_OBJECT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>move-exception</code> rop for the
* given type. The result may be a shared instance.
*
* @param type non-null; type of the exception
* @return non-null; an appropriate instance
*/
public static Rop opMoveException(TypeBearer type) {
return new Rop(RegOps.MOVE_EXCEPTION, type.getType(),
StdTypeList.EMPTY, (String) null);
}
/**
* Returns the appropriate <code>move-result</code> rop for the
* given type. The result may be a shared instance.
*
* @param type non-null; type of the parameter
* @return non-null; an appropriate instance
*/
public static Rop opMoveResult(TypeBearer type) {
return new Rop(RegOps.MOVE_RESULT, type.getType(),
StdTypeList.EMPTY, (String) null);
}
/**
* Returns the appropriate <code>move-result-pseudo</code> rop for the
* given type. The result may be a shared instance.
*
* @param type non-null; type of the parameter
* @return non-null; an appropriate instance
*/
public static Rop opMoveResultPseudo(TypeBearer type) {
return new Rop(RegOps.MOVE_RESULT_PSEUDO, type.getType(),
StdTypeList.EMPTY, (String) null);
}
/**
* Returns the appropriate <code>const</code> rop for the given
* type. The result is a shared instance.
*
* @param type non-null; type of the constant
* @return non-null; an appropriate instance
*/
public static Rop opConst(TypeBearer type) {
if (type.getType() == Type.KNOWN_NULL) {
return CONST_OBJECT_NOTHROW;
}
switch (type.getBasicFrameType()) {
case Type.BT_INT: return CONST_INT;
case Type.BT_LONG: return CONST_LONG;
case Type.BT_FLOAT: return CONST_FLOAT;
case Type.BT_DOUBLE: return CONST_DOUBLE;
case Type.BT_OBJECT: return CONST_OBJECT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>if-eq</code> rop for the given
* sources. The result is a shared instance.
*
* @param types non-null; source types
* @return non-null; an appropriate instance
*/
public static Rop opIfEq(TypeList types) {
return pickIf(types, IF_EQZ_INT, IF_EQZ_OBJECT,
IF_EQ_INT, IF_EQ_OBJECT);
}
/**
* Returns the appropriate <code>if-ne</code> rop for the given
* sources. The result is a shared instance.
*
* @param types non-null; source types
* @return non-null; an appropriate instance
*/
public static Rop opIfNe(TypeList types) {
return pickIf(types, IF_NEZ_INT, IF_NEZ_OBJECT,
IF_NE_INT, IF_NE_OBJECT);
}
/**
* Returns the appropriate <code>if-lt</code> rop for the given
* sources. The result is a shared instance.
*
* @param types non-null; source types
* @return non-null; an appropriate instance
*/
public static Rop opIfLt(TypeList types) {
return pickIf(types, IF_LTZ_INT, null, IF_LT_INT, null);
}
/**
* Returns the appropriate <code>if-ge</code> rop for the given
* sources. The result is a shared instance.
*
* @param types non-null; source types
* @return non-null; an appropriate instance
*/
public static Rop opIfGe(TypeList types) {
return pickIf(types, IF_GEZ_INT, null, IF_GE_INT, null);
}
/**
* Returns the appropriate <code>if-gt</code> rop for the given
* sources. The result is a shared instance.
*
* @param types non-null; source types
* @return non-null; an appropriate instance
*/
public static Rop opIfGt(TypeList types) {
return pickIf(types, IF_GTZ_INT, null, IF_GT_INT, null);
}
/**
* Returns the appropriate <code>if-le</code> rop for the given
* sources. The result is a shared instance.
*
* @param types non-null; source types
* @return non-null; an appropriate instance
*/
public static Rop opIfLe(TypeList types) {
return pickIf(types, IF_LEZ_INT, null, IF_LE_INT, null);
}
/**
* Helper for all the <code>if*</code>-related methods, which
* checks types and picks one of the four variants, throwing if
* there's a problem.
*
* @param types non-null; the types
* @param intZ non-null; the int-to-0 comparison
* @param objZ null-ok; the object-to-null comparison
* @param intInt non-null; the int-to-int comparison
* @param objObj non-null; the object-to-object comparison
* @return non-null; the appropriate instance
*/
private static Rop pickIf(TypeList types, Rop intZ, Rop objZ, Rop intInt,
Rop objObj) {
switch(types.size()) {
case 1: {
switch (types.getType(0).getBasicFrameType()) {
case Type.BT_INT: {
return intZ;
}
case Type.BT_OBJECT: {
if (objZ != null) {
return objZ;
}
}
}
break;
}
case 2: {
int bt = types.getType(0).getBasicFrameType();
if (bt == types.getType(1).getBasicFrameType()) {
switch (bt) {
case Type.BT_INT: {
return intInt;
}
case Type.BT_OBJECT: {
if (objObj != null) {
return objObj;
}
}
}
}
break;
}
}
return throwBadTypes(types);
}
/**
* Returns the appropriate <code>add</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opAdd(TypeList types) {
return pickBinaryOp(types, ADD_CONST_INT, ADD_CONST_LONG,
ADD_CONST_FLOAT, ADD_CONST_DOUBLE, ADD_INT,
ADD_LONG, ADD_FLOAT, ADD_DOUBLE);
}
/**
* Returns the appropriate <code>sub</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opSub(TypeList types) {
return pickBinaryOp(types, SUB_CONST_INT, SUB_CONST_LONG,
SUB_CONST_FLOAT, SUB_CONST_DOUBLE, SUB_INT,
SUB_LONG, SUB_FLOAT, SUB_DOUBLE);
}
/**
* Returns the appropriate <code>mul</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opMul(TypeList types) {
return pickBinaryOp(types, MUL_CONST_INT, MUL_CONST_LONG,
MUL_CONST_FLOAT, MUL_CONST_DOUBLE, MUL_INT,
MUL_LONG, MUL_FLOAT, MUL_DOUBLE);
}
/**
* Returns the appropriate <code>div</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opDiv(TypeList types) {
return pickBinaryOp(types, DIV_CONST_INT, DIV_CONST_LONG,
DIV_CONST_FLOAT, DIV_CONST_DOUBLE, DIV_INT,
DIV_LONG, DIV_FLOAT, DIV_DOUBLE);
}
/**
* Returns the appropriate <code>rem</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opRem(TypeList types) {
return pickBinaryOp(types, REM_CONST_INT, REM_CONST_LONG,
REM_CONST_FLOAT, REM_CONST_DOUBLE, REM_INT,
REM_LONG, REM_FLOAT, REM_DOUBLE);
}
/**
* Returns the appropriate <code>and</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opAnd(TypeList types) {
return pickBinaryOp(types, AND_CONST_INT, AND_CONST_LONG, null, null,
AND_INT, AND_LONG, null, null);
}
/**
* Returns the appropriate <code>or</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opOr(TypeList types) {
return pickBinaryOp(types, OR_CONST_INT, OR_CONST_LONG, null, null,
OR_INT, OR_LONG, null, null);
}
/**
* Returns the appropriate <code>xor</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opXor(TypeList types) {
return pickBinaryOp(types, XOR_CONST_INT, XOR_CONST_LONG, null, null,
XOR_INT, XOR_LONG, null, null);
}
/**
* Returns the appropriate <code>shl</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opShl(TypeList types) {
return pickBinaryOp(types, SHL_CONST_INT, SHL_CONST_LONG, null, null,
SHL_INT, SHL_LONG, null, null);
}
/**
* Returns the appropriate <code>shr</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opShr(TypeList types) {
return pickBinaryOp(types, SHR_CONST_INT, SHR_CONST_LONG, null, null,
SHR_INT, SHR_LONG, null, null);
}
/**
* Returns the appropriate <code>ushr</code> rop for the given
* types. The result is a shared instance.
*
* @param types non-null; types of the sources
* @return non-null; an appropriate instance
*/
public static Rop opUshr(TypeList types) {
return pickBinaryOp(types, USHR_CONST_INT, USHR_CONST_LONG, null, null,
USHR_INT, USHR_LONG, null, null);
}
/**
* Returns the appropriate binary arithmetic rop for the given type
* and arguments. The result is a shared instance.
*
* @param types non-null; sources of the operation
* @param int1 non-null; the int-to-constant rop
* @param long1 non-null; the long-to-constant rop
* @param float1 null-ok; the float-to-constant rop, if any
* @param double1 null-ok; the double-to-constant rop, if any
* @param int2 non-null; the int-to-int rop
* @param long2 non-null; the long-to-long or long-to-int rop
* @param float2 null-ok; the float-to-float rop, if any
* @param double2 null-ok; the double-to-double rop, if any
* @return non-null; an appropriate instance
*/
private static Rop pickBinaryOp(TypeList types, Rop int1, Rop long1,
Rop float1, Rop double1, Rop int2,
Rop long2, Rop float2, Rop double2) {
int bt1 = types.getType(0).getBasicFrameType();
Rop result = null;
switch (types.size()) {
case 1: {
switch(bt1) {
case Type.BT_INT: return int1;
case Type.BT_LONG: return long1;
case Type.BT_FLOAT: result = float1; break;
case Type.BT_DOUBLE: result = double1; break;
}
break;
}
case 2: {
switch(bt1) {
case Type.BT_INT: return int2;
case Type.BT_LONG: return long2;
case Type.BT_FLOAT: result = float2; break;
case Type.BT_DOUBLE: result = double2; break;
}
break;
}
}
if (result == null) {
return throwBadTypes(types);
}
return result;
}
/**
* Returns the appropriate <code>neg</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; type of value being operated on
* @return non-null; an appropriate instance
*/
public static Rop opNeg(TypeBearer type) {
switch (type.getBasicFrameType()) {
case Type.BT_INT: return NEG_INT;
case Type.BT_LONG: return NEG_LONG;
case Type.BT_FLOAT: return NEG_FLOAT;
case Type.BT_DOUBLE: return NEG_DOUBLE;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>not</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; type of value being operated on
* @return non-null; an appropriate instance
*/
public static Rop opNot(TypeBearer type) {
switch (type.getBasicFrameType()) {
case Type.BT_INT: return NOT_INT;
case Type.BT_LONG: return NOT_LONG;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>cmpl</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; type of value being compared
* @return non-null; an appropriate instance
*/
public static Rop opCmpl(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_LONG: return CMPL_LONG;
case Type.BT_FLOAT: return CMPL_FLOAT;
case Type.BT_DOUBLE: return CMPL_DOUBLE;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>cmpg</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; type of value being compared
* @return non-null; an appropriate instance
*/
public static Rop opCmpg(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_FLOAT: return CMPG_FLOAT;
case Type.BT_DOUBLE: return CMPG_DOUBLE;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>conv</code> rop for the given types. The
* result is a shared instance.
*
* @param dest non-null; target value type
* @param source non-null; source value type
* @return non-null; an appropriate instance
*/
public static Rop opConv(TypeBearer dest, TypeBearer source) {
int dbt = dest.getBasicFrameType();
switch (source.getBasicFrameType()) {
case Type.BT_INT: {
switch (dbt) {
case Type.BT_LONG: return CONV_I2L;
case Type.BT_FLOAT: return CONV_I2F;
case Type.BT_DOUBLE: return CONV_I2D;
}
}
case Type.BT_LONG: {
switch (dbt) {
case Type.BT_INT: return CONV_L2I;
case Type.BT_FLOAT: return CONV_L2F;
case Type.BT_DOUBLE: return CONV_L2D;
}
}
case Type.BT_FLOAT: {
switch (dbt) {
case Type.BT_INT: return CONV_F2I;
case Type.BT_LONG: return CONV_F2L;
case Type.BT_DOUBLE: return CONV_F2D;
}
}
case Type.BT_DOUBLE: {
switch (dbt) {
case Type.BT_INT: return CONV_D2I;
case Type.BT_LONG: return CONV_D2L;
case Type.BT_FLOAT: return CONV_D2F;
}
}
}
return throwBadTypes(StdTypeList.make(dest.getType(),
source.getType()));
}
/**
* Returns the appropriate <code>return</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; type of value being returned
* @return non-null; an appropriate instance
*/
public static Rop opReturn(TypeBearer type) {
switch (type.getBasicFrameType()) {
case Type.BT_INT: return RETURN_INT;
case Type.BT_LONG: return RETURN_LONG;
case Type.BT_FLOAT: return RETURN_FLOAT;
case Type.BT_DOUBLE: return RETURN_DOUBLE;
case Type.BT_OBJECT: return RETURN_OBJECT;
case Type.BT_VOID: return RETURN_VOID;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>aget</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; element type of array being accessed
* @return non-null; an appropriate instance
*/
public static Rop opAget(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_INT: return AGET_INT;
case Type.BT_LONG: return AGET_LONG;
case Type.BT_FLOAT: return AGET_FLOAT;
case Type.BT_DOUBLE: return AGET_DOUBLE;
case Type.BT_OBJECT: return AGET_OBJECT;
case Type.BT_BOOLEAN: return AGET_BOOLEAN;
case Type.BT_BYTE: return AGET_BYTE;
case Type.BT_CHAR: return AGET_CHAR;
case Type.BT_SHORT: return AGET_SHORT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>aput</code> rop for the given type. The
* result is a shared instance.
*
* @param type non-null; element type of array being accessed
* @return non-null; an appropriate instance
*/
public static Rop opAput(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_INT: return APUT_INT;
case Type.BT_LONG: return APUT_LONG;
case Type.BT_FLOAT: return APUT_FLOAT;
case Type.BT_DOUBLE: return APUT_DOUBLE;
case Type.BT_OBJECT: return APUT_OBJECT;
case Type.BT_BOOLEAN: return APUT_BOOLEAN;
case Type.BT_BYTE: return APUT_BYTE;
case Type.BT_CHAR: return APUT_CHAR;
case Type.BT_SHORT: return APUT_SHORT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>new-array</code> rop for the given
* type. The result is a shared instance.
*
* @param arrayType non-null; array type of array being created
* @return non-null; an appropriate instance
*/
public static Rop opNewArray(TypeBearer arrayType) {
Type type = arrayType.getType();
Type elementType = type.getComponentType();
switch (elementType.getBasicType()) {
case Type.BT_INT: return NEW_ARRAY_INT;
case Type.BT_LONG: return NEW_ARRAY_LONG;
case Type.BT_FLOAT: return NEW_ARRAY_FLOAT;
case Type.BT_DOUBLE: return NEW_ARRAY_DOUBLE;
case Type.BT_BOOLEAN: return NEW_ARRAY_BOOLEAN;
case Type.BT_BYTE: return NEW_ARRAY_BYTE;
case Type.BT_CHAR: return NEW_ARRAY_CHAR;
case Type.BT_SHORT: return NEW_ARRAY_SHORT;
case Type.BT_OBJECT: {
return new Rop(RegOps.NEW_ARRAY, type, StdTypeList.INT,
Exceptions.LIST_Error_NegativeArraySizeException,
"new-array-object");
}
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>filled-new-array</code> rop for the given
* type. The result may be a shared instance.
*
* @param arrayType non-null; type of array being created
* @param count >= 0; number of elements that the array should have
* @return non-null; an appropriate instance
*/
public static Rop opFilledNewArray(TypeBearer arrayType, int count) {
Type type = arrayType.getType();
Type elementType = type.getComponentType();
if (elementType.isCategory2()) {
return throwBadType(arrayType);
}
if (count < 0) {
throw new IllegalArgumentException("count < 0");
}
StdTypeList sourceTypes = new StdTypeList(count);
for (int i = 0; i < count; i++) {
sourceTypes.set(i, elementType);
}
// Note: The resulting rop is considered call-like.
return new Rop(RegOps.FILLED_NEW_ARRAY,
sourceTypes,
Exceptions.LIST_Error);
}
/**
* Returns the appropriate <code>get-field</code> rop for the given
* type. The result is a shared instance.
*
* @param type non-null; type of the field in question
* @return non-null; an appropriate instance
*/
public static Rop opGetField(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_INT: return GET_FIELD_INT;
case Type.BT_LONG: return GET_FIELD_LONG;
case Type.BT_FLOAT: return GET_FIELD_FLOAT;
case Type.BT_DOUBLE: return GET_FIELD_DOUBLE;
case Type.BT_OBJECT: return GET_FIELD_OBJECT;
case Type.BT_BOOLEAN: return GET_FIELD_BOOLEAN;
case Type.BT_BYTE: return GET_FIELD_BYTE;
case Type.BT_CHAR: return GET_FIELD_CHAR;
case Type.BT_SHORT: return GET_FIELD_SHORT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>put-field</code> rop for the given
* type. The result is a shared instance.
*
* @param type non-null; type of the field in question
* @return non-null; an appropriate instance
*/
public static Rop opPutField(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_INT: return PUT_FIELD_INT;
case Type.BT_LONG: return PUT_FIELD_LONG;
case Type.BT_FLOAT: return PUT_FIELD_FLOAT;
case Type.BT_DOUBLE: return PUT_FIELD_DOUBLE;
case Type.BT_OBJECT: return PUT_FIELD_OBJECT;
case Type.BT_BOOLEAN: return PUT_FIELD_BOOLEAN;
case Type.BT_BYTE: return PUT_FIELD_BYTE;
case Type.BT_CHAR: return PUT_FIELD_CHAR;
case Type.BT_SHORT: return PUT_FIELD_SHORT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>get-static</code> rop for the given
* type. The result is a shared instance.
*
* @param type non-null; type of the field in question
* @return non-null; an appropriate instance
*/
public static Rop opGetStatic(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_INT: return GET_STATIC_INT;
case Type.BT_LONG: return GET_STATIC_LONG;
case Type.BT_FLOAT: return GET_STATIC_FLOAT;
case Type.BT_DOUBLE: return GET_STATIC_DOUBLE;
case Type.BT_OBJECT: return GET_STATIC_OBJECT;
case Type.BT_BOOLEAN: return GET_STATIC_BOOLEAN;
case Type.BT_BYTE: return GET_STATIC_BYTE;
case Type.BT_CHAR: return GET_STATIC_CHAR;
case Type.BT_SHORT: return GET_STATIC_SHORT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>put-static</code> rop for the given
* type. The result is a shared instance.
*
* @param type non-null; type of the field in question
* @return non-null; an appropriate instance
*/
public static Rop opPutStatic(TypeBearer type) {
switch (type.getBasicType()) {
case Type.BT_INT: return PUT_STATIC_INT;
case Type.BT_LONG: return PUT_STATIC_LONG;
case Type.BT_FLOAT: return PUT_STATIC_FLOAT;
case Type.BT_DOUBLE: return PUT_STATIC_DOUBLE;
case Type.BT_OBJECT: return PUT_STATIC_OBJECT;
case Type.BT_BOOLEAN: return PUT_STATIC_BOOLEAN;
case Type.BT_BYTE: return PUT_STATIC_BYTE;
case Type.BT_CHAR: return PUT_STATIC_CHAR;
case Type.BT_SHORT: return PUT_STATIC_SHORT;
}
return throwBadType(type);
}
/**
* Returns the appropriate <code>invoke-static</code> rop for the
* given type. The result is typically a newly-allocated instance.
*
* @param meth non-null; descriptor of the method
* @return non-null; an appropriate instance
*/
public static Rop opInvokeStatic(Prototype meth) {
return new Rop(RegOps.INVOKE_STATIC,
meth.getParameterFrameTypes(),
StdTypeList.THROWABLE);
}
/**
* Returns the appropriate <code>invoke-virtual</code> rop for the
* given type. The result is typically a newly-allocated instance.
*
* @param meth non-null; descriptor of the method, including the
* <code>this</code> parameter
* @return non-null; an appropriate instance
*/
public static Rop opInvokeVirtual(Prototype meth) {
return new Rop(RegOps.INVOKE_VIRTUAL,
meth.getParameterFrameTypes(),
StdTypeList.THROWABLE);
}
/**
* Returns the appropriate <code>invoke-super</code> rop for the
* given type. The result is typically a newly-allocated instance.
*
* @param meth non-null; descriptor of the method, including the
* <code>this</code> parameter
* @return non-null; an appropriate instance
*/
public static Rop opInvokeSuper(Prototype meth) {
return new Rop(RegOps.INVOKE_SUPER,
meth.getParameterFrameTypes(),
StdTypeList.THROWABLE);
}
/**
* Returns the appropriate <code>invoke-direct</code> rop for the
* given type. The result is typically a newly-allocated instance.
*
* @param meth non-null; descriptor of the method, including the
* <code>this</code> parameter
* @return non-null; an appropriate instance
*/
public static Rop opInvokeDirect(Prototype meth) {
return new Rop(RegOps.INVOKE_DIRECT,
meth.getParameterFrameTypes(),
StdTypeList.THROWABLE);
}
/**
* Returns the appropriate <code>invoke-interface</code> rop for the
* given type. The result is typically a newly-allocated instance.
*
* @param meth non-null; descriptor of the method, including the
* <code>this</code> parameter
* @return non-null; an appropriate instance
*/
public static Rop opInvokeInterface(Prototype meth) {
return new Rop(RegOps.INVOKE_INTERFACE,
meth.getParameterFrameTypes(),
StdTypeList.THROWABLE);
}
/**
* Returns the appropriate <code>mark-local</code> rop for the given type.
* The result is a shared instance.
*
* @param type non-null; type of value being marked
* @return non-null; an appropriate instance
*/
public static Rop opMarkLocal(TypeBearer type) {
switch (type.getBasicFrameType()) {
case Type.BT_INT: return MARK_LOCAL_INT;
case Type.BT_LONG: return MARK_LOCAL_LONG;
case Type.BT_FLOAT: return MARK_LOCAL_FLOAT;
case Type.BT_DOUBLE: return MARK_LOCAL_DOUBLE;
case Type.BT_OBJECT: return MARK_LOCAL_OBJECT;
}
return throwBadType(type);
}
/**
* This class is uninstantiable.
*/
private Rops() {
// This space intentionally left blank.
}
/**
* Throws the right exception to complain about a bogus type.
*
* @param type non-null; the bad type
* @return never
*/
private static Rop throwBadType(TypeBearer type) {
throw new IllegalArgumentException("bad type: " + type);
}
/**
* Throws the right exception to complain about a bogus list of types.
*
* @param types non-null; the bad types
* @return never
*/
private static Rop throwBadTypes(TypeList types) {
throw new IllegalArgumentException("bad types: " + types);
}
}
|
