(type2.isWordType() && op2.asIntConstant().value == 0) ||
(type2.isWordType() && op2.asAddressConstant().value.EQ(Address.zero())) ||
  public static boolean conservativelyApproximates(OPT_Operand op1,                                                    OPT_Operand op2) {    // Step 1: Handle pointer equality and bottom    if (op1 == op2) {      if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {        if (op2 == null) {          VM.sysWrite("operands are both bottom therefore trivially true\n");        } else {          VM.sysWrite("operands are identical therefore trivially true\n");        }      }      return true;    }    if (op1 == null) {      if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {        VM.sysWrite("op1 is bottom, therefore trivially true\n");      }      return true;    }    if (op2 == null) {      if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {        VM.sysWrite("op2 is bottom, therefore trivially false\n");      }      return false;    }    // Now, handle the non-trivial cases:    // Step 2: op1 is a constant but op2 is not the same constant    if (op1.isConstant()) {      if (op1.similar(op2)) {        if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {          VM.sysWrite("operands are similar constants\n");        }        return true;      } else {        if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {          VM.sysWrite("op1 is a constant but op2 is not the same constant\n");        }        return false;      }    }    // Step 3: op1 is a RegisterOperand    // This case is complicated by the need to ensure that the     // various Flag bits are considered as well....    if (op1.isRegister()) {      OPT_RegisterOperand rop1 = op1.asRegister();      VM_TypeReference type1 = rop1.type;      if (op2.isRegister()) {        OPT_RegisterOperand rop2 = op2.asRegister();        VM_TypeReference type2 = rop2.type;        if (type1 == type2) {          if (rop1.hasLessConservativeFlags(rop2)) {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("Operands are registers of identical type, but incompatible flags\n");            }            return false;          } else if (OPT_BC2IR.hasLessConservativeGuard(rop1, rop2)) {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("Operands are registers of identical type, but with incompatible non-null guards\n");            }            return false;          } else {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("Operands are compatible register operands\n");            }            return true;          }        } else if (compatiblePrimitives(type1, type2) ||                   OPT_ClassLoaderProxy.includesType(type1, type2) == OPT_Constants.YES) {          // types are ok, only have to worry about the flags          if (rop1.isPreciseType() || rop1.hasLessConservativeFlags(rop2)) {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("Flag mismatch between type compatible register operands\n");            }            return false;          } else if (OPT_BC2IR.hasLessConservativeGuard(rop1, rop2)) {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("Non-null guard mismatch between type compatible register operands\n");            }            return false;          } else {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("Operands are compatible register operands\n");            }            return true;          }        } else {          if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {            VM.sysWrite("Operands are type incompatible register operands\n");          }          return false;        }      } else {        // op2 is not a register        if (op2 instanceof OPT_BC2IR.ReturnAddressOperand ||             op2 == OPT_BC2IR.DUMMY) {          if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {            VM.sysWrite("Operands are incompatibale values\n");          }          return false;        }                VM_TypeReference type2 = op2.getType();        if (type1 == type2 ||             compatiblePrimitives(type1, type2) ||            (OPT_ClassLoaderProxy.includesType(type1, type2) == OPT_Constants.YES)) {          // only have to consider state of op1's flags.  Types are ok.          if (rop1.isPreciseType() && (type1 != type2)) {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("op1 preciseType bit will be incorrect\n");            }            return false;          }          if ((rop1.scratchObject instanceof OPT_Operand) &&               ((type2 == VM_TypeReference.NULL_TYPE) ||               (type2.isIntLikeType() && op2.asIntConstant().value == 0) ||               (type2.isWordType() && op2.asIntConstant().value == 0) ||               (type2.isLongType() && op2.asLongConstant().value == 0L))) {            if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {              VM.sysWrite("op1 non null guard will be incorrect");            }            return false;          }          if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {            VM.sysWrite("(Constant) op2 was compatible with register op1\n");          }          return true;        } else {          if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {            VM.sysWrite("Op2 not compatible with register op1\n");          }          return false;        }      }    }    // Step 4: op1 is a OPT_IRGEN operand of some form    if (op1.similar(op2)) {      if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {        VM.sysWrite("Compatible OPT_BC2IR.* operands\n");      }      return true;    } else {      if (OPT_IRGenOptions.DBG_OPERAND_LATTICE) {        VM.sysWrite("Incompatible OPT_BC2IR.* operands\n");      }      return false;    }  }