gt:             case RegOps.SUB: return opSub(sources);
context: /*
   * 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()} */
      public static final Rop NOP =
          new Rop(RegOps.NOP, Type.VOID, StdTypeList.EMPTY, "nop");
  
      /** {@code r,x: int :: r = x;} */
      public static final Rop MOVE_INT =
          new Rop(RegOps.MOVE, Type.INT, StdTypeList.INT, "move-int");
  
      /** {@code r,x: long :: r = x;} */
      public static final Rop MOVE_LONG =
          new Rop(RegOps.MOVE, Type.LONG, StdTypeList.LONG, "move-long");
  
      /** {@code r,x: float :: r = x;} */
      public static final Rop MOVE_FLOAT =
          new Rop(RegOps.MOVE, Type.FLOAT, StdTypeList.FLOAT, "move-float");
  
      /** {@code r,x: double :: r = x;} */
      public static final Rop MOVE_DOUBLE =
          new Rop(RegOps.MOVE, Type.DOUBLE, StdTypeList.DOUBLE, "move-double");
  
      /** {@code r,x: Object :: r = x;} */
      public static final Rop MOVE_OBJECT =
          new Rop(RegOps.MOVE, Type.OBJECT, StdTypeList.OBJECT, "move-object");
  
      /**
       * {@code r,x: ReturnAddress :: r = x;}
       *
       * 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);} */
      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);} */
      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);} */
      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);} */
      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);} */
      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;} */
      public static final Rop CONST_INT =
          new Rop(RegOps.CONST, Type.INT, StdTypeList.EMPTY, "const-int");
  
      /** {@code r, literal: long :: r = literal;} */
      public static final Rop CONST_LONG =
          new Rop(RegOps.CONST, Type.LONG, StdTypeList.EMPTY, "const-long");
  
      /** {@code r, literal: float :: r = literal;} */
      public static final Rop CONST_FLOAT =
          new Rop(RegOps.CONST, Type.FLOAT, StdTypeList.EMPTY, "const-float");
  
      /** {@code r, literal: double :: r = literal;} */
      public static final Rop CONST_DOUBLE =
          new Rop(RegOps.CONST, Type.DOUBLE, StdTypeList.EMPTY, "const-double");
  
      /** {@code r, literal: Object :: r = literal;} */
      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;} */
      public static final Rop CONST_OBJECT_NOTHROW =
          new Rop(RegOps.CONST, Type.OBJECT, StdTypeList.EMPTY,
                  "const-object-nothrow");
  
      /** {@code goto label} */
      public static final Rop GOTO =
          new Rop(RegOps.GOTO, Type.VOID, StdTypeList.EMPTY, Rop.BRANCH_GOTO,
                  "goto");
  
      /** {@code x: int :: if (x == 0) goto label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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 label} */
      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]} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      public static final Rop REM_DOUBLE =
          new Rop(RegOps.REM, Type.DOUBLE, StdTypeList.DOUBLE_DOUBLE,
                  "rem-double");
  
      /** {@code r,x: int :: r = -x;} */
      public static final Rop NEG_INT =
          new Rop(RegOps.NEG, Type.INT, StdTypeList.INT, "neg-int");
  
      /** {@code r,x: long :: r = -x;} */
      public static final Rop NEG_LONG =
          new Rop(RegOps.NEG, Type.LONG, StdTypeList.LONG, "neg-long");
  
      /** {@code r,x: float :: r = -x;} */
      public static final Rop NEG_FLOAT =
          new Rop(RegOps.NEG, Type.FLOAT, StdTypeList.FLOAT, "neg-float");
  
      /** {@code r,x: double :: r = -x;} */
      public static final Rop NEG_DOUBLE =
          new Rop(RegOps.NEG, Type.DOUBLE, StdTypeList.DOUBLE, "neg-double");
  
      /** {@code r,x,y: int :: r = x & y;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      public static final Rop USHR_LONG =
          new Rop(RegOps.USHR, Type.LONG, StdTypeList.LONG_INT, "ushr-long");
  
      /** {@code r,x: int :: r = ~x;} */
      public static final Rop NOT_INT =
          new Rop(RegOps.NOT, Type.INT, StdTypeList.INT, "not-int");
  
      /** {@code r,x: long :: r = ~x;} */
      public static final Rop NOT_LONG =
          new Rop(RegOps.NOT, Type.LONG, StdTypeList.LONG, "not-long");
  
      /** {@code r,x,c: int :: r = x + c;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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;} */
      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);} */
      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);} */
      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);} */
      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);} */
      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);} */
      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} */
      public static final Rop CONV_L2I =
          new Rop(RegOps.CONV, Type.INT, StdTypeList.LONG, "conv-l2i");
  
      /** {@code r: int; x: float :: r = (int) x} */
      public static final Rop CONV_F2I =
          new Rop(RegOps.CONV, Type.INT, StdTypeList.FLOAT, "conv-f2i");
  
      /** {@code r: int; x: double :: r = (int) x} */
      public static final Rop CONV_D2I =
          new Rop(RegOps.CONV, Type.INT, StdTypeList.DOUBLE, "conv-d2i");
  
      /** {@code r: long; x: int :: r = (long) x} */
      public static final Rop CONV_I2L =
          new Rop(RegOps.CONV, Type.LONG, StdTypeList.INT, "conv-i2l");
  
      /** {@code r: long; x: float :: r = (long) x} */
      public static final Rop CONV_F2L =
          new Rop(RegOps.CONV, Type.LONG, StdTypeList.FLOAT, "conv-f2l");
  
      /** {@code r: long; x: double :: r = (long) x} */
      public static final Rop CONV_D2L =
          new Rop(RegOps.CONV, Type.LONG, StdTypeList.DOUBLE, "conv-d2l");
  
      /** {@code r: float; x: int :: r = (float) x} */
      public static final Rop CONV_I2F =
          new Rop(RegOps.CONV, Type.FLOAT, StdTypeList.INT, "conv-i2f");
  
      /** {@code r: float; x: long :: r = (float) x} */
      public static final Rop CONV_L2F =
          new Rop(RegOps.CONV, Type.FLOAT, StdTypeList.LONG, "conv-l2f");
  
      /** {@code r: float; x: double :: r = (float) x} */
      public static final Rop CONV_D2F =
          new Rop(RegOps.CONV, Type.FLOAT, StdTypeList.DOUBLE, "conv-d2f");
  
      /** {@code r: double; x: int :: r = (double) x} */
      public static final Rop CONV_I2D =
          new Rop(RegOps.CONV, Type.DOUBLE, StdTypeList.INT, "conv-i2d");
  
      /** {@code r: double; x: long :: r = (double) x} */
      public static final Rop CONV_L2D =
          new Rop(RegOps.CONV, Type.DOUBLE, StdTypeList.LONG, "conv-l2d");
  
      /** {@code r: double; x: float :: r = (double) x} */
      public static final Rop CONV_F2D =
          new Rop(RegOps.CONV, Type.DOUBLE, StdTypeList.FLOAT, "conv-f2d");
  
      /**
       * {@code r,x: int :: r = (x << 24) >> 24} (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} (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} (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} */
      public static final Rop RETURN_VOID =
          new Rop(RegOps.RETURN, Type.VOID, StdTypeList.EMPTY, Rop.BRANCH_RETURN,
                  "return-void");
  
      /** {@code x: int; return x} */
      public static final Rop RETURN_INT =
          new Rop(RegOps.RETURN, Type.VOID, StdTypeList.INT, Rop.BRANCH_RETURN,
                  "return-int");
  
      /** {@code x: long; return x} */
      public static final Rop RETURN_LONG =
          new Rop(RegOps.RETURN, Type.VOID, StdTypeList.LONG, Rop.BRANCH_RETURN,
                  "return-long");
  
      /** {@code x: float; return x} */
      public static final Rop RETURN_FLOAT =
          new Rop(RegOps.RETURN, Type.VOID, StdTypeList.FLOAT, Rop.BRANCH_RETURN,
                  "return-float");
  
      /** {@code x: double; return x} */
      public static final Rop RETURN_DOUBLE =
          new Rop(RegOps.RETURN, Type.VOID, StdTypeList.DOUBLE,
                  Rop.BRANCH_RETURN, "return-double");
  
      /** {@code x: Object; return x} */
      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} */
      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)} */
      public static final Rop THROW =
          new Rop(RegOps.THROW, Type.VOID, StdTypeList.THROWABLE,
                  StdTypeList.THROWABLE, "throw");
  
      /** {@code x: Object :: monitorenter(x)} */
      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)} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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)} (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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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]} */
      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} (can
       * throw {@code ClassCastException}) 
       */
      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}. Note: This is listed as throwing {@code Error}
       * 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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} 
       */
      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} */
      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} */
      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} */
      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} */
      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} */
      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}
       */
      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} */
      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} */
      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} */
      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}} */
      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 {@code non-null;} destination (result) type, or
       * {@link Type#VOID} if none
       * @param sources {@code non-null;} list of source types
       * @param cst {@code null-ok;} associated constant, if any
       * @return {@code 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);
  