if (meth.getDeclaringClass().isWordType()) { try { boolean generated = OPT_GenerateMagic.generateMagic(this, gc, meth); if (generated) { if (gc.options.PRINT_DETAILED_INLINE_REPORT) OPT_InlineReport.isMagic(meth); break; } } catch (OPT_MagicNotImplementedException e) { if (gc.options.PRINT_DETAILED_INLINE_REPORT) { OPT_InlineReport.unimplementedMagic(Call.getMethod(s).method); } throw e; } } boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(meth, gc.method.getDeclaringClass()); if (!unresolved) meth = meth.resolve(); OPT_MethodOperand methOp = OPT_MethodOperand.VIRTUAL(meth, unresolved); s = _callHelper(methOp); if (s == null) { if (gc.options.PRINT_DETAILED_INLINE_REPORT) { OPT_InlineReport.instructionNull(); } break; }     OPT_Operand ref = Call.getParam(s, 0); boolean receiverClassResolved = false; boolean isExtant = false; VM_Type type = null; if (ref.isRegister()) { isExtant = ref.asRegister().isExtant(); type = ref.asRegister().type; } else if (ref.isStringConstant()) { isExtant = true; type = OPT_ClassLoaderProxy.JavaLangStringType; } else if (VM.VerifyAssertions) VM._assert(false, "unexpected receiver"); receiverClassResolved = type.isResolved(); if ((meth.getDeclaringClass() != type) && type.isClassType()) { VM_Method vmeth = OPT_ClassLoaderProxy.lookupMethod(type.asClass(), meth); if (vmeth != null && vmeth != meth) {  meth = vmeth; unresolved = OPT_ClassLoaderProxy.needsDynamicLink(meth, gc.method.getDeclaringClass()); Call.setMethod(s, OPT_MethodOperand.VIRTUAL(meth, unresolved, true)); } } if (gc.options.PRINT_DETAILED_INLINE_REPORT) OPT_InlineReport.classUnresolved(unresolved, meth);  if (!unresolved) {      VM_Method computedTarget = null; if (receiverClassResolved && ((ref.isStringConstant()) || ref.asRegister().isPreciseType())) { computedTarget = meth; if (gc.options.PRINT_DETAILED_INLINE_REPORT) OPT_InlineReport.isPreciseType(); } OPT_InlineDecision id = shouldInline(s, computedTarget, isExtant); if (maybeInlineMethod(id, s)) { return; } }   rectifyStateWithExceptionHandlers(); } break;  case JBC_invokespecial: { if (gc.options.PRINT_DETAILED_INLINE_REPORT) { OPT_InlineReport.beginNewDecision(); OPT_InlineReport.setCallType(OPT_InlineReport.INVOKE_SPECIAL); } VM_Method meth = bcodes.getMethodReference();    boolean unresolved = !meth.getDeclaringClass().isResolved() || (OPT_ClassLoaderProxy.findSpecialMethod(meth) == null);
boolean unresolved = !meth.getDeclaringClass().isResolved() || (OPT_ClassLoaderProxy.findSpecialMethod(meth) == null);
  private void generateFrom(int fromIndex) {    if (DBG_BB || DBG_SELECTED) {      db("generating code into " + currentBBLE + " with runoff " + runoff);    }    currentBBLE.setGenerated();    endOfBasicBlock = fallThrough = false;    lastInstr = null;    bcodes.reset(fromIndex);    while (true) {      // Must keep currentBBLE.high up-to-date in case we try to jump into       // the middle of the block we're currently generating.  Simply updating       // high once endsBasicBlock is true doesn't enable us to catch this case.      currentBBLE.high = instrIndex = bcodes.index();      int code = bcodes.nextInstruction();      if (DBG_BCPARSE) {        db("parsing " + instrIndex + " " + code + " : 0x" + Integer.toHexString(code));      }      OPT_Instruction s = null;      switch (code) {      case JBC_nop:	break;      case JBC_aconst_null:	push(new OPT_NullConstantOperand());	break;      case JBC_iconst_m1:case JBC_iconst_0:case JBC_iconst_1:      case JBC_iconst_2:case JBC_iconst_3:case JBC_iconst_4:      case JBC_iconst_5:	push(new OPT_IntConstantOperand(code - JBC_iconst_0));	break;      case JBC_lconst_0:case JBC_lconst_1:	pushDual(new OPT_LongConstantOperand(code - JBC_lconst_0));	break;      case JBC_fconst_0:	push(new OPT_FloatConstantOperand(0.f));	break;      case JBC_fconst_1:	push(new OPT_FloatConstantOperand(1.f));	break;      case JBC_fconst_2:	push(new OPT_FloatConstantOperand(2.f));	break;      case JBC_dconst_0:	pushDual(new OPT_DoubleConstantOperand(0.));	break;      case JBC_dconst_1:	pushDual(new OPT_DoubleConstantOperand(1.));	break;      case JBC_bipush:	push(new OPT_IntConstantOperand(bcodes.getByteValue()));	break;	      case JBC_sipush:	push(new OPT_IntConstantOperand(bcodes.getShortValue()));	break;      case JBC_ldc:	push(getConstantOperand(bcodes.getConstantIndex()));	break;      case JBC_ldc_w:	push(getConstantOperand(bcodes.getWideConstantIndex()));	break;      case JBC_ldc2_w:	pushDual(getConstantOperand(bcodes.getWideConstantIndex()));	break;      case JBC_iload:	s = do_iload(bcodes.getLocalNumber());	break;      case JBC_lload:	s = do_lload(bcodes.getLocalNumber());	break;      case JBC_fload:	s = do_fload(bcodes.getLocalNumber());	break;      case JBC_dload:	s = do_dload(bcodes.getLocalNumber());	break;      case JBC_aload:	s = do_aload(bcodes.getLocalNumber());	break;      case JBC_iload_0:case JBC_iload_1:case JBC_iload_2:case JBC_iload_3:	s = do_iload(code - JBC_iload_0);	break;      case JBC_lload_0:case JBC_lload_1:case JBC_lload_2:case JBC_lload_3:	s = do_lload(code - JBC_lload_0);	break;            case JBC_fload_0:case JBC_fload_1:case JBC_fload_2:case JBC_fload_3:	s = do_fload(code - JBC_fload_0);	break;            case JBC_dload_0:case JBC_dload_1:case JBC_dload_2:case JBC_dload_3:	s = do_dload(code - JBC_dload_0);	break;      case JBC_aload_0:case JBC_aload_1:case JBC_aload_2:case JBC_aload_3:	s = do_aload(code - JBC_aload_0);	break;      case JBC_iaload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.IntArrayType);	  s = _aloadHelper(INT_ALOAD, ref, index, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_laload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.LongArrayType);	  s = _aloadHelper(LONG_ALOAD, ref, index, OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_faload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.FloatArrayType);	  s = _aloadHelper(FLOAT_ALOAD, ref, index, OPT_ClassLoaderProxy.FloatType);	}	break;	        case JBC_daload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.DoubleArrayType);	  s = _aloadHelper(DOUBLE_ALOAD, ref, index, OPT_ClassLoaderProxy.DoubleType);	}	break;      case JBC_aaload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  VM_Type type = getRefTypeOf(ref).asArray().getElementType();	  if (VM.VerifyAssertions) VM._assert(type.isReferenceType());	  s = _aloadHelper(REF_ALOAD, ref, index, type);	}	break;      case JBC_baload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  VM_Type type = getArrayTypeOf(ref);	  if (VM.VerifyAssertions) {	    VM._assert(type == OPT_ClassLoaderProxy.ByteArrayType || 		      type == OPT_ClassLoaderProxy.BooleanArrayType);	  }	  if (type == OPT_ClassLoaderProxy.ByteArrayType)	    s = _aloadHelper(BYTE_ALOAD, ref, index, OPT_ClassLoaderProxy.ByteType);	  else 	    s = _aloadHelper(UBYTE_ALOAD, ref, index, OPT_ClassLoaderProxy.BooleanType);	}	break;      case JBC_caload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.CharArrayType);	  s = _aloadHelper(USHORT_ALOAD, ref, index, OPT_ClassLoaderProxy.CharType);	}	break;	      case JBC_saload:	{	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.ShortArrayType);	  s = _aloadHelper(SHORT_ALOAD, ref, index, OPT_ClassLoaderProxy.ShortType);	}	break;      case JBC_istore:	s = do_store(bcodes.getLocalNumber(), popInt());	break;      case JBC_lstore:	s = do_store(bcodes.getLocalNumber(), popLong());	break;      case JBC_fstore:	s = do_store(bcodes.getLocalNumber(), popFloat());	break;      case JBC_dstore:	s = do_store(bcodes.getLocalNumber(), popDouble());	break;      case JBC_astore:	s = do_astore(bcodes.getLocalNumber());	break;      case JBC_istore_0:case JBC_istore_1:case JBC_istore_2:case JBC_istore_3:	s = do_store(code - JBC_istore_0, popInt());	break;      case JBC_lstore_0:case JBC_lstore_1:case JBC_lstore_2:case JBC_lstore_3:	s = do_store(code - JBC_lstore_0, popLong());	break;      case JBC_fstore_0:case JBC_fstore_1:case JBC_fstore_2:case JBC_fstore_3:	s = do_store(code - JBC_fstore_0, popFloat());	break;      case JBC_dstore_0:case JBC_dstore_1:case JBC_dstore_2:case JBC_dstore_3:	s = do_store(code - JBC_dstore_0, popDouble());	break;      case JBC_astore_0:case JBC_astore_1:case JBC_astore_2:case JBC_astore_3:	s = do_astore(code - JBC_astore_0);	break;      case JBC_iastore:	{	  OPT_Operand val = popInt();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	      assertIsType(ref, OPT_ClassLoaderProxy.IntArrayType);	  s = AStore.create(INT_ASTORE, val, ref, index,			    new OPT_LocationOperand(OPT_ClassLoaderProxy.IntType),			    getCurrentGuard());	}	break;      case JBC_lastore:	{	  OPT_Operand val = popLong();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.LongArrayType);	  s = AStore.create(LONG_ASTORE, val, ref, index, 			    new OPT_LocationOperand(OPT_ClassLoaderProxy.LongType),			    getCurrentGuard());	}	break;      case JBC_fastore:	{	  OPT_Operand val = popFloat();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.FloatArrayType);	  s = AStore.create(FLOAT_ASTORE, val, ref, index, 			    new OPT_LocationOperand(OPT_ClassLoaderProxy.FloatType),			    getCurrentGuard());	}	break;      case JBC_dastore:	{	  OPT_Operand val = popDouble();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.DoubleArrayType);	  s = AStore.create(DOUBLE_ASTORE, val, ref, index, 			    new OPT_LocationOperand(OPT_ClassLoaderProxy.DoubleType),			    getCurrentGuard());	}	break;      case JBC_aastore:	{	  OPT_Operand val = pop();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  VM_Type type = getRefTypeOf(ref).asArray().getElementType();	  if (VM.VerifyAssertions) VM._assert(type.isReferenceType());	  if (do_CheckStore(ref, val, type))	      break;	  s = AStore.create(REF_ASTORE, 			    val, ref, index,			    new OPT_LocationOperand(type),			    getCurrentGuard());	}	break;      case JBC_bastore:	{	  OPT_Operand val = popInt();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  VM_Type type = getArrayTypeOf(ref);	  if (VM.VerifyAssertions) {	    VM._assert(type == OPT_ClassLoaderProxy.ByteArrayType || 		      type == OPT_ClassLoaderProxy.BooleanArrayType);	  }	  if (type == OPT_ClassLoaderProxy.ByteArrayType)	    type = OPT_ClassLoaderProxy.ByteType;	  else 	    type = OPT_ClassLoaderProxy.BooleanType;	  s = AStore.create(BYTE_ASTORE, val, ref, index,			    new OPT_LocationOperand(type),			    getCurrentGuard());	}	break;      case JBC_castore:	{	  OPT_Operand val = popInt();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.CharArrayType);	  s = AStore.create(SHORT_ASTORE, val, ref, index,			    new OPT_LocationOperand(OPT_ClassLoaderProxy.CharType),			    getCurrentGuard());	}	break;      case JBC_sastore:	{	  OPT_Operand val = popInt();	  OPT_Operand index = popInt();	  OPT_Operand ref = pop();	  clearCurrentGuard();	  if (do_NullCheck(ref) || do_BoundsCheck(ref, index))	    break;	  if (VM.VerifyAssertions)	    assertIsType(ref, OPT_ClassLoaderProxy.ShortArrayType);	  s = AStore.create(SHORT_ASTORE, val, ref, index,			    new OPT_LocationOperand(OPT_ClassLoaderProxy.ShortType),			    getCurrentGuard());	}	break;      case JBC_pop:	stack.pop();	break;      case JBC_pop2:	stack.pop2();	break;      case JBC_dup:	{	  OPT_Operand op1 = stack.pop();	  stack.push(op1);	  s = pushCopy(op1);	}	break;      case JBC_dup_x1:	{	  OPT_Operand op1 = stack.pop();	  OPT_Operand op2 = stack.pop();	  stack.push(op1);	  stack.push(op2);	  s = pushCopy(op1);	}	break;      case JBC_dup_x2:	{	  OPT_Operand op1 = stack.pop();	  OPT_Operand op2 = stack.pop();	  OPT_Operand op3 = stack.pop();	  stack.push(op1);	  stack.push(op3);	  stack.push(op2);	  s = pushCopy(op1);	}	break;      case JBC_dup2:	{	  OPT_Operand op1 = stack.pop();	  OPT_Operand op2 = stack.pop();	  stack.push(op2);	  stack.push(op1);	  s = pushCopy(op2);	  if (s != null) {	    appendInstruction(s);	    s = null;	  }	  s = pushCopy(op1);	}	break;      case JBC_dup2_x1:	{	  OPT_Operand op1 = stack.pop();	  OPT_Operand op2 = stack.pop();	  OPT_Operand op3 = stack.pop();	  stack.push(op2);	  stack.push(op1);	  stack.push(op3);	  s = pushCopy(op2);	  if (s != null) {	    appendInstruction(s);	    s = null;	  }	  s = pushCopy(op1);	}	break;      case JBC_dup2_x2:	{	  OPT_Operand op1 = stack.pop();	  OPT_Operand op2 = stack.pop();	  OPT_Operand op3 = stack.pop();	  OPT_Operand op4 = stack.pop();	  stack.push(op2);	  stack.push(op1);	  stack.push(op4);	  stack.push(op3);	  s = pushCopy(op2);	  if (s != null) {	    appendInstruction(s);	    s = null;	  }	  s = pushCopy(op1);	}	break;      case JBC_swap:	{	  OPT_Operand op1 = stack.pop();	  OPT_Operand op2 = stack.pop();	  stack.push(op1);	  stack.push(op2);	}	break;      case JBC_iadd:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_ADD, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_ladd:	{	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_ADD, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_fadd:	{	  OPT_Operand op2 = popFloat();	  OPT_Operand op1 = popFloat();	  s = _binaryHelper(FLOAT_ADD, op1, op2, OPT_ClassLoaderProxy.FloatType);	}	break;      case JBC_dadd:	{	  OPT_Operand op2 = popDouble();	  OPT_Operand op1 = popDouble();	  s = _binaryDualHelper(DOUBLE_ADD, op1, op2, OPT_ClassLoaderProxy.DoubleType);	}	break;      case JBC_isub:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_SUB, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lsub:	{	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_SUB, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_fsub:	{	  OPT_Operand op2 = popFloat();	  OPT_Operand op1 = popFloat();	  s = _binaryHelper(FLOAT_SUB, op1, op2, OPT_ClassLoaderProxy.FloatType);	}	break;      case JBC_dsub:	{	  OPT_Operand op2 = popDouble();	  OPT_Operand op1 = popDouble();	  s = _binaryDualHelper(DOUBLE_SUB, op1, op2, OPT_ClassLoaderProxy.DoubleType);	}	break;      case JBC_imul:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_MUL, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lmul:	{	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_MUL, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_fmul:	{	  OPT_Operand op2 = popFloat();	  OPT_Operand op1 = popFloat();	  s = _binaryHelper(FLOAT_MUL, op1, op2, OPT_ClassLoaderProxy.FloatType);	}	break;      case JBC_dmul:	{	  OPT_Operand op2 = popDouble();	  OPT_Operand op1 = popDouble();	  s = _binaryDualHelper(DOUBLE_MUL, op1, op2, OPT_ClassLoaderProxy.DoubleType);	}	break;      case JBC_idiv:	{	  clearCurrentGuard();	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  if (do_IntZeroCheck(op2))	    break;	  s = _guardedBinaryHelper(INT_DIV, op1, op2, getCurrentGuard(), 				   OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_ldiv:	{	  clearCurrentGuard();	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  if (do_LongZeroCheck(op2))	    break;	  s = _guardedBinaryDualHelper(LONG_DIV, op1, op2, getCurrentGuard(), 				       OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_fdiv:	{	  OPT_Operand op2 = popFloat();	  OPT_Operand op1 = popFloat();	  s = _binaryHelper(FLOAT_DIV, op1, op2, OPT_ClassLoaderProxy.FloatType);	}	break;      case JBC_ddiv:	{	  OPT_Operand op2 = popDouble();	  OPT_Operand op1 = popDouble();	  s = _binaryDualHelper(DOUBLE_DIV, op1, op2, OPT_ClassLoaderProxy.DoubleType);	}	break;      case JBC_irem:	{	  clearCurrentGuard();	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  if (do_IntZeroCheck(op2))	    break;	  s = _guardedBinaryHelper(INT_REM, op1, op2, getCurrentGuard(), 				   OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lrem:	{	  clearCurrentGuard();	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  if (do_LongZeroCheck(op2))	    break;	  s = _guardedBinaryDualHelper(LONG_REM, op1, op2, getCurrentGuard(), 				       OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_frem:	{	  OPT_Operand op2 = popFloat();	  OPT_Operand op1 = popFloat();	  s = _binaryHelper(FLOAT_REM, op1, op2, OPT_ClassLoaderProxy.FloatType);	}	break;      case JBC_drem:	{	  OPT_Operand op2 = popDouble();	  OPT_Operand op1 = popDouble();	  s = _binaryDualHelper(DOUBLE_REM, op1, op2, OPT_ClassLoaderProxy.DoubleType);	}	break;      case JBC_ineg:	s = _unaryHelper(INT_NEG, popInt(), OPT_ClassLoaderProxy.IntType);	break;      case JBC_lneg:	s = _unaryDualHelper(LONG_NEG, popLong(), OPT_ClassLoaderProxy.LongType);	break;      case JBC_fneg:	s = _unaryHelper(FLOAT_NEG, popFloat(), OPT_ClassLoaderProxy.FloatType);	break;      case JBC_dneg:	s = _unaryDualHelper(DOUBLE_NEG, popDouble(), OPT_ClassLoaderProxy.DoubleType);	break;      case JBC_ishl:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_SHL, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lshl:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_SHL, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;            case JBC_ishr:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_SHR, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lshr:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_SHR, op1, op2, OPT_ClassLoaderProxy.LongType);	} 	break;      case JBC_iushr:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_USHR, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lushr:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_USHR, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;            case JBC_iand:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_AND, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_land:	{	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_AND, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_ior:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_OR, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lor:	{	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_OR, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_ixor:	{	  OPT_Operand op2 = popInt();	  OPT_Operand op1 = popInt();	  s = _binaryHelper(INT_XOR, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_lxor:	{	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  s = _binaryDualHelper(LONG_XOR, op1, op2, OPT_ClassLoaderProxy.LongType);	}	break;      case JBC_iinc:	{	  int index = bcodes.getLocalNumber();	  s = do_iinc(index, bcodes.getIncrement());	}	break;      case JBC_i2l:	s = _unaryDualHelper(INT_2LONG, popInt(), OPT_ClassLoaderProxy.LongType);	break;      case JBC_i2f:	s = _unaryHelper(INT_2FLOAT, popInt(), OPT_ClassLoaderProxy.FloatType);	break;      case JBC_i2d:	s = _unaryDualHelper(INT_2DOUBLE, popInt(), OPT_ClassLoaderProxy.DoubleType);	break;      case JBC_l2i:	s = _unaryHelper(LONG_2INT, popLong(), OPT_ClassLoaderProxy.IntType);	break;      case JBC_l2f:	s = _unaryHelper(LONG_2FLOAT, popLong(), OPT_ClassLoaderProxy.FloatType);	break;      case JBC_l2d:	s = _unaryDualHelper(LONG_2DOUBLE, popLong(), OPT_ClassLoaderProxy.DoubleType);	break;      case JBC_f2i:	s = _unaryHelper(FLOAT_2INT, popFloat(), OPT_ClassLoaderProxy.IntType);	break;      case JBC_f2l:	s = _unaryDualHelper(FLOAT_2LONG, popFloat(), OPT_ClassLoaderProxy.LongType);	break;      case JBC_f2d:	s = _unaryDualHelper(FLOAT_2DOUBLE, popFloat(), OPT_ClassLoaderProxy.DoubleType);	break;      case JBC_d2i:	s = _unaryHelper(DOUBLE_2INT, popDouble(), OPT_ClassLoaderProxy.IntType);	break;      case JBC_d2l:	s = _unaryDualHelper(DOUBLE_2LONG, popDouble(), OPT_ClassLoaderProxy.LongType);	break;      case JBC_d2f:	s = _unaryHelper(DOUBLE_2FLOAT, popDouble(), OPT_ClassLoaderProxy.FloatType);	break;      case JBC_int2byte:	s = _unaryHelper(INT_2BYTE, popInt(), OPT_ClassLoaderProxy.ByteType);	break;      case JBC_int2char:	s = _unaryHelper(INT_2USHORT, popInt(), OPT_ClassLoaderProxy.CharType);	break;      case JBC_int2short:	s = _unaryHelper(INT_2SHORT, popInt(), OPT_ClassLoaderProxy.ShortType);	break;      case JBC_lcmp:	{	  OPT_Operand op2 = popLong();	  OPT_Operand op1 = popLong();	  s = _binaryHelper(LONG_CMP, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_fcmpl:	{	  OPT_Operand op2 = popFloat();	  OPT_Operand op1 = popFloat();	  s = _binaryHelper(FLOAT_CMPL, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;            case JBC_fcmpg:	{	  OPT_Operand op2 = popFloat();	  OPT_Operand op1 = popFloat();	  s = _binaryHelper(FLOAT_CMPG, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_dcmpl:	{	  OPT_Operand op2 = popDouble();	  OPT_Operand op1 = popDouble();	  s = _binaryHelper(DOUBLE_CMPL, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_dcmpg:	{	  OPT_Operand op2 = popDouble();	  OPT_Operand op1 = popDouble();	  s = _binaryHelper(DOUBLE_CMPG, op1, op2, OPT_ClassLoaderProxy.IntType);	}	break;      case JBC_ifeq:	s = _intIfHelper(OPT_ConditionOperand.EQUAL());	break;      case JBC_ifne:	s = _intIfHelper(OPT_ConditionOperand.NOT_EQUAL());	break;      case JBC_iflt:	s = _intIfHelper(OPT_ConditionOperand.LESS());	break;      case JBC_ifge:	s = _intIfHelper(OPT_ConditionOperand.GREATER_EQUAL());	break;      case JBC_ifgt:	s = _intIfHelper(OPT_ConditionOperand.GREATER());	break;      case JBC_ifle:	s = _intIfHelper(OPT_ConditionOperand.LESS_EQUAL());	break;      case JBC_if_icmpeq:	s = _intIfCmpHelper(OPT_ConditionOperand.EQUAL());	break;      case JBC_if_icmpne:	s = _intIfCmpHelper(OPT_ConditionOperand.NOT_EQUAL());	break;      case JBC_if_icmplt:	s = _intIfCmpHelper(OPT_ConditionOperand.LESS());	break;      case JBC_if_icmpge:	s = _intIfCmpHelper(OPT_ConditionOperand.GREATER_EQUAL());	break;      case JBC_if_icmpgt:	s = _intIfCmpHelper(OPT_ConditionOperand.GREATER());	break;      case JBC_if_icmple:	s = _intIfCmpHelper(OPT_ConditionOperand.LESS_EQUAL());	break;      case JBC_if_acmpeq:	s = _refIfCmpHelper(OPT_ConditionOperand.EQUAL());	break;      case JBC_if_acmpne:	s = _refIfCmpHelper(OPT_ConditionOperand.NOT_EQUAL());	break;      case JBC_goto:	{	  int offset = bcodes.getBranchOffset();	  if (offset != 3)   // skip generating frivolous goto's	    s = _gotoHelper(offset);	}	break;      case JBC_jsr:	s = _jsrHelper(bcodes.getBranchOffset());	break;      case JBC_ret:	s = _retHelper(bcodes.getLocalNumber());	break;      case JBC_tableswitch:	{	  bcodes.alignSwitch();	  OPT_Operand op0 = popInt();	  int defaultoff = bcodes.getDefaultSwitchOffset();	  int low = bcodes.getLowSwitchValue();	  int high = bcodes.getHighSwitchValue();	  int number = high - low + 1;	  if (CF_TABLESWITCH && op0 instanceof OPT_IntConstantOperand) {	    int v1 = ((OPT_IntConstantOperand)op0).value;	    int match = bcodes.computeTableSwitchOffset(v1, low, high);	    int offset = match == 0 ? defaultoff : match;	    bcodes.skipTableSwitchOffsets(number);	    if (DBG_CF) {	      db("changed tableswitch to goto because index (" + v1 + ") is constant");	    }	    s = _gotoHelper(offset);	    break;	  }	  s = TableSwitch.create(TABLESWITCH, op0, null, null, 				 new OPT_IntConstantOperand(low), 				 new OPT_IntConstantOperand(high), 				 generateTarget(defaultoff), 				 null,				 number*2);	  for (int i = 0; i < number; ++i) {	    TableSwitch.setTarget(s, i, generateTarget(bcodes.getTableSwitchOffset(i)));	  }	  bcodes.skipTableSwitchOffsets(number);	  	  // Set branch probabilities	  VM_SwitchBranchProfile sp = gc.getSwitchProfile(instrIndex);	  if (sp == null) {	    float approxProb = 1.0f/(float)(number+1); // number targets + default	    TableSwitch.setDefaultBranchProfile(s, new OPT_BranchProfileOperand(approxProb));	    for (int i = 0; i < number; ++i) {	      TableSwitch.setBranchProfile(s, i, new OPT_BranchProfileOperand(approxProb));	    }	  } else {	    TableSwitch.setDefaultBranchProfile(s, new OPT_BranchProfileOperand(sp.getDefaultProbability()));	    for (int i = 0; i < number; ++i) {	      TableSwitch.setBranchProfile(s, i, new OPT_BranchProfileOperand(sp.getCaseProbability(i)));	    }	  }	}	break;      case JBC_lookupswitch:	{	  bcodes.alignSwitch();	  OPT_Operand op0 = popInt();	  int defaultoff = bcodes.getDefaultSwitchOffset();	  int numpairs = bcodes.getSwitchLength();	  if (numpairs == 0) {	    s = _gotoHelper(defaultoff);	    break;	  }	  if (CF_LOOKUPSWITCH && op0 instanceof OPT_IntConstantOperand) {	    int v1 = ((OPT_IntConstantOperand)op0).value;	    int match = bcodes.computeLookupSwitchOffset(v1, numpairs);	    int offset = match == 0 ? defaultoff : match;	    bcodes.skipLookupSwitchPairs(numpairs);	    if (DBG_CF) {	      db("changed lookupswitch to goto because index (" + v1 + ") is constant");	    }	    s = _gotoHelper(offset);	    break;	  }	  // Construct switch	  s = LookupSwitch.create(LOOKUPSWITCH, op0, null, null, 				  generateTarget(defaultoff), 				  null,  numpairs*3);	  for (int i = 0; i < numpairs; ++i) {	    LookupSwitch.setMatch(s, i, new OPT_IntConstantOperand(bcodes.getLookupSwitchValue(i)));	    LookupSwitch.setTarget(s, i, generateTarget(bcodes.getLookupSwitchOffset(i)));	  }	  bcodes.skipLookupSwitchPairs(numpairs);	  // Set branch probabilities	  VM_SwitchBranchProfile sp = gc.getSwitchProfile(instrIndex);	  if (sp == null) {	    float approxProb = 1.0f/(float)(numpairs+1); // num targets + default	    LookupSwitch.setDefaultBranchProfile(s, new OPT_BranchProfileOperand(approxProb));	    for (int i = 0; i < numpairs; ++i) {	      LookupSwitch.setBranchProfile(s, i, new OPT_BranchProfileOperand(approxProb));	    }	  } else {	    LookupSwitch.setDefaultBranchProfile(s, new OPT_BranchProfileOperand(sp.getDefaultProbability()));	    for (int i = 0; i < numpairs; ++i) {	      LookupSwitch.setBranchProfile(s, i, new OPT_BranchProfileOperand(sp.getCaseProbability(i)));	    }	  }	}	break;      case JBC_ireturn:	_returnHelper(INT_MOVE, popInt());	break;      case JBC_lreturn:	_returnHelper(LONG_MOVE, popLong());	break;      case JBC_freturn:	_returnHelper(FLOAT_MOVE, popFloat());	break;      case JBC_dreturn:	_returnHelper(DOUBLE_MOVE, popDouble());	break;      case JBC_areturn:	{	  OPT_Operand op0 = popRef();	  if (VM.VerifyAssertions && !op0.isDefinitelyNull()) {	    VM_Type retType = getRefTypeOf(op0);	    // fudge to deal with conservative approximation 	    // in OPT_ClassLoaderProxy.findCommonSuperclass	    if (retType != OPT_ClassLoaderProxy.JavaLangObjectType)	      assertIsAssignable(gc.method.getReturnType(), getRefTypeOf(op0));	  }	  _returnHelper(REF_MOVE, op0);	}	break;      case JBC_return:	_returnHelper(null, null);	break;      case JBC_getstatic:	{	  VM_Field field = bcodes.getFieldReference();	  // use results of field analysis to refine type.	  VM_Type fieldType = field.getType();          OPT_RegisterOperand t = gc.temps.makeTemp(fieldType);	  if (field.getType().isClassType() && 	      field.getType().asClass().isLoaded()) {	    VM_Type concreteType = OPT_FieldAnalysis.getConcreteType(field);	    if (concreteType != null) {	      t.setPreciseType();	      if (concreteType == fieldType) {		t.setDeclaredType();	      } else {		fieldType = concreteType;		t.type = concreteType;	      }	    }	  }	  boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(field, gc.method.getDeclaringClass());	  OPT_Operator operator = unresolved?GETSTATIC_UNRESOLVED:GETSTATIC;	  if (!unresolved) field = field.resolve();	  s = GetStatic.create(operator, t, makeStaticFieldRef(field));	  // optimization: 	  // if the field is final and either initialized or	  // in the bootimage, then get the value at compile time.	  // TODO: applying this optimization to Floats or Doubles 	  //       causes problems.  Figure out why and fix it!	  if (!fieldType.isDoubleType() && !fieldType.isFloatType()) {	    if (!unresolved && field.isFinal()) {	      VM_Class declaringClass = field.getDeclaringClass();	      if (declaringClass.isInitialized() ||		  (VM.writingBootImage && declaringClass.isInBootImage())) {		try {		  if (fieldType.isPrimitiveType()) {		    operator = OPT_IRTools.getMoveOp(field.getType());		    OPT_ConstantOperand rhs = OPT_StaticFieldReader.getStaticFieldValue(field);		    // VM.sysWrite("Replaced getstatic of "+field+" with "+rhs+"\n");		    push (rhs, fieldType);		    s = null;		    break;		  } else {		    if (OPT_StaticFieldReader.isStaticFieldNull(field)) {		      // VM.sysWrite("Replaced getstatic of "+field+" with <null>\n");		      push(new OPT_NullConstantOperand(), fieldType);		      s = null;		      break;		    } else {		      VM_Type rtType = OPT_StaticFieldReader.getTypeFromStaticField(field);		      if (rtType == VM_Type.JavaLangStringType) {			OPT_ConstantOperand rhs = OPT_StaticFieldReader.getStaticFieldValue(field);			// VM.sysWrite("Replaced getstatic of "+field+" with "+rhs+"\n");			push (rhs, fieldType);			s = null;			break;		      } else {			t.type = rtType;			if (rtType != fieldType) t.clearDeclaredType();			t.setPreciseType();			markGuardlessNonNull(t);			// VM.sysWrite("Tightened type info for getstatic of "+field+" to "+t+"\n");		      }		    }		  }		} catch (NoSuchFieldException e) {		  // Sigh, host JDK java.* class didn't have this RVM field.		  // VM.sysWrite("Field "+field+" does not exist on host JDK\n");		}	      }	    }	  }	  push(t.copyD2U(), fieldType);	  if (unresolved)	    rectifyStateWithErrorHandler();	}	break;      case JBC_putstatic:	{	  VM_Field field = bcodes.getFieldReference();	  VM_Type fieldType = field.getType();	  OPT_Operand r = pop(fieldType);	  boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(field, gc.method.getDeclaringClass());	  OPT_Operator operator = unresolved?PUTSTATIC_UNRESOLVED:PUTSTATIC;	  if (!unresolved) field = field.resolve();	  s = PutStatic.create(operator, r, makeStaticFieldRef(field));	  if (unresolved)	    rectifyStateWithErrorHandler();	}	break;      case JBC_getfield:	{	  OPT_Operand op1 = pop();	  clearCurrentGuard();	  if (do_NullCheck(op1))	    break;	  VM_Field field = bcodes.getFieldReference();	  VM_Type fieldType = field.getType();          OPT_RegisterOperand t = gc.temps.makeTemp(fieldType);	  // use results of field analysis to refine type.	  if (field.getType().isClassType() && 	      field.getType().asClass().isLoaded()) {	    VM_Type concreteType = OPT_FieldAnalysis.getConcreteType(field);	    if (concreteType != null) {	      t.setPreciseType();	      if (concreteType == fieldType) {		t.setDeclaredType();	      } else {		fieldType = concreteType;		t.type = concreteType;	      }	    }	  }	  boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(field, gc.method.getDeclaringClass());	  OPT_Operator operator = unresolved?GETFIELD_UNRESOLVED:GETFIELD;	  if (!unresolved) field = field.resolve();	  s = GetField.create(operator, t, op1, makeInstanceFieldRef(field), 			      getCurrentGuard());	  push(t.copyD2U(), fieldType);	  if (unresolved)	    rectifyStateWithErrorHandler();	}	break;      case JBC_putfield:	{	  VM_Field field = bcodes.getFieldReference();	  VM_Type fieldType = field.getType();	  OPT_Operand val = pop(fieldType);	  OPT_Operand obj = popRef();	  clearCurrentGuard();	  if (do_NullCheck(obj))	    break;	  boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(field, gc.method.getDeclaringClass());	  OPT_Operator operator = unresolved?PUTFIELD_UNRESOLVED:PUTFIELD;	  if (!unresolved) field = field.resolve();	  s = PutField.create(operator, val, obj, makeInstanceFieldRef(field), 			      getCurrentGuard());	  if (unresolved)	    rectifyStateWithErrorHandler();	}	break;      case JBC_invokevirtual:	{	  if (gc.options.PRINT_DETAILED_INLINE_REPORT) {	    OPT_InlineReport.beginNewDecision();	    OPT_InlineReport.setCallType(OPT_InlineReport.INVOKE_VIRTUAL);	  }	  VM_Method meth = bcodes.getMethodReference();	  if (meth.getDeclaringClass().isWordType()) {	    try {	      boolean generated = OPT_GenerateMagic.generateMagic(this, gc, meth);	      if (generated) {		if (gc.options.PRINT_DETAILED_INLINE_REPORT) 		  OPT_InlineReport.isMagic(meth);		break;	      }	    } catch (OPT_MagicNotImplementedException e) {	      if (gc.options.PRINT_DETAILED_INLINE_REPORT) {		OPT_InlineReport.unimplementedMagic(Call.getMethod(s).method);	      }	      throw e;	    }	  }	  boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(meth, gc.method.getDeclaringClass());	  if (!unresolved) meth = meth.resolve();	  OPT_MethodOperand methOp = 	    OPT_MethodOperand.VIRTUAL(meth, unresolved);	  s = _callHelper(methOp);	  if (s == null) {	    if (gc.options.PRINT_DETAILED_INLINE_REPORT) {	      OPT_InlineReport.instructionNull();	    }	    break;	  }	  // try to reduce the number of targets.	  // If we succeed, we'll update meth, unresolved, 	  // and s's method operand.	  OPT_Operand ref = Call.getParam(s, 0);	  boolean receiverClassResolved = false;	  boolean isExtant = false;	  VM_Type type = null;	  if (ref.isRegister()) {	    isExtant = ref.asRegister().isExtant();	    type = ref.asRegister().type;	  } else if (ref.isStringConstant()) {	    isExtant = true;	    type = OPT_ClassLoaderProxy.JavaLangStringType;	  } else if (VM.VerifyAssertions)	    VM._assert(false, "unexpected receiver");	  receiverClassResolved = type.isResolved();	  if ((meth.getDeclaringClass() != type) && type.isClassType()) {	    VM_Method vmeth = 		OPT_ClassLoaderProxy.lookupMethod(type.asClass(), meth);	    if (vmeth != null && vmeth != meth) {	      // Update meth to be the refined vmeth	      meth = vmeth;	      unresolved = OPT_ClassLoaderProxy.needsDynamicLink(meth, gc.method.getDeclaringClass());	      Call.setMethod(s, OPT_MethodOperand.VIRTUAL(meth, unresolved, true));	    }	  }	  if (gc.options.PRINT_DETAILED_INLINE_REPORT)	    OPT_InlineReport.classUnresolved(unresolved, meth);	  // If we don't need dynamic linking code, think about inlining	  if (!unresolved) {	    // if the type is precise and receiverClassResolved is true	    // then we know FOR CERTAIN that this call will resolve to meth.	    // By ensuring that recieverClassResolved, we make sure that 	    // lookupMethod was able to actually search the class hierarchy 	    // and set meth appropriately.	    VM_Method computedTarget = null;	    if (receiverClassResolved && 		((ref.isStringConstant()) || 		 ref.asRegister().isPreciseType())) {	      computedTarget = meth;	      if (gc.options.PRINT_DETAILED_INLINE_REPORT)		OPT_InlineReport.isPreciseType();	    }            OPT_InlineDecision id = shouldInline(s, computedTarget, isExtant);            if (maybeInlineMethod(id, s)) {              return;            }          }	  // CALL must be treated as potential throw of anything	  rectifyStateWithExceptionHandlers(); 	}	break;      case JBC_invokespecial:	{	  if (gc.options.PRINT_DETAILED_INLINE_REPORT) {	    OPT_InlineReport.beginNewDecision();	    OPT_InlineReport.setCallType(OPT_InlineReport.INVOKE_SPECIAL);	  }	  VM_Method meth = bcodes.getMethodReference();	  // Note: this is not the usual needsDynamicLink 	  // due to semantics of invokespecial	  // See comments in VM_OptLinker, OPT_Convert2Low, VM_Linker.  	  boolean unresolved = 	    !meth.getDeclaringClass().isResolved() ||	    (OPT_ClassLoaderProxy.findSpecialMethod(meth) == null);	  if (!unresolved) meth = meth.resolve();	  s = _callHelper(OPT_MethodOperand.SPECIAL(meth, unresolved));	  if (s == null) {	    if (gc.options.PRINT_DETAILED_INLINE_REPORT) {	      OPT_InlineReport.instructionNull();	    }	    break;	  }	  if (gc.options.PRINT_DETAILED_INLINE_REPORT)	    OPT_InlineReport.classUnresolved(unresolved, meth);	  // If we don't need dynamic linking code, think about inlining	  if (!unresolved) {	    if (maybeInlineMethod(shouldInline(s, null, false), s)) {	      return;	    }	  }	  // CALL must be treated as potential throw of anything	  rectifyStateWithExceptionHandlers(); 	}	break;      case JBC_invokestatic:	{	  if (gc.options.PRINT_DETAILED_INLINE_REPORT) {	    OPT_InlineReport.beginNewDecision();	    OPT_InlineReport.setCallType(OPT_InlineReport.INVOKE_STATIC);	  }	  VM_Method meth = bcodes.getMethodReference();	  if (meth.getDeclaringClass().isMagicType() ||	      meth.getDeclaringClass().isWordType()) {	    try {	      boolean generated = OPT_GenerateMagic.generateMagic(this, gc, meth);	      if (generated) {		if (gc.options.PRINT_DETAILED_INLINE_REPORT) 		  OPT_InlineReport.isMagic(meth);		break;	      }	    } catch (OPT_MagicNotImplementedException e) {	      if (gc.options.PRINT_DETAILED_INLINE_REPORT) {		OPT_InlineReport.unimplementedMagic(Call.getMethod(s).method);	      }	      if (gc.options.SKIP_UNKNOWN_MAGIC) {		s = _callHelper(OPT_MethodOperand.STATIC(meth, false));		// CALL must be treated as potential throw of anything		rectifyStateWithExceptionHandlers();		break;	      } else {		throw  (e);	      }	    }	  }	  boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(meth, gc.method.getDeclaringClass());	  if (!unresolved) meth = meth.resolve();	  s = _callHelper(OPT_MethodOperand.STATIC(meth, unresolved));	  if (gc.options.PRINT_DETAILED_INLINE_REPORT)	    OPT_InlineReport.classUnresolved(unresolved, meth);	  // If we don't need dynamic linking code, think about inlining	  if (!unresolved) {	    if (maybeInlineMethod(shouldInline(s, null, false), s)) {	      return;	    }	  }	  // CALL must be treated as potential throw of anything	  rectifyStateWithExceptionHandlers();	}	break;      case JBC_invokeinterface:	{	  if (gc.options.PRINT_DETAILED_INLINE_REPORT) {	    OPT_InlineReport.beginNewDecision();	    OPT_InlineReport.setCallType(OPT_InlineReport.INVOKE_INTERFACE);	  }	  VM_Method meth = bcodes.getMethodReference();	  bcodes.alignInvokeInterface();	  OPT_MethodOperand methOp = OPT_MethodOperand.INTERFACE(meth, false);	  s = _callHelper(methOp);	  if (s == null) {	    if (gc.options.PRINT_DETAILED_INLINE_REPORT) {	      OPT_InlineReport.instructionNull();	    }	    break;	  }	  OPT_RegisterOperand ref = Call.getParam(s, 0).asRegister();	  VM_Class refType = ref.type.asClass();	  VM_Type interfaceType = meth.getDeclaringClass();	  boolean requiresImplementsTest = 	    VM.BuildForIMTInterfaceInvocation ||	    (VM.BuildForITableInterfaceInvocation && VM.DirectlyIndexedITables);	  // Step 1: handle the possibility of ghost references	  try {	    VM_Method resolvedMethodRef = meth.resolveInterfaceMethod(false);	    if (resolvedMethodRef == null		// Include this here in case it is needed later		) {	      if (requiresImplementsTest) {		// might be a ghost reference. 		// Must do the more involved typechecking sequence		OPT_RegisterOperand tibPtr = 		  gc.temps.makeTemp(OPT_ClassLoaderProxy.JavaLangObjectArrayType);		OPT_Instruction getTib = 		    GuardedUnary.create(GET_OBJ_TIB, tibPtr, 		      ref.copyU2U(), 		      getCurrentGuard());		appendInstruction(getTib);		getTib.bcIndex = RUNTIME_SERVICES_BCI;		OPT_MethodOperand dtcRoutine = 		  OPT_MethodOperand.STATIC(VM_Entrypoints.unresolvedInvokeinterfaceImplementsTestMethod);		OPT_Instruction callCheck =		    Call.create2(CALL, null, null, dtcRoutine, 		      new OPT_IntConstantOperand(meth.getDictionaryId()),		      tibPtr.copyD2U());                if (gc.options.NO_CALLEE_EXCEPTIONS) {                  callCheck.markAsNonPEI();                }		appendInstruction(callCheck);		callCheck.bcIndex = RUNTIME_SERVICES_BCI;		requiresImplementsTest = false; // the above call subsumes the test	      }	    } else {	      meth = resolvedMethodRef;	      Call.setMethod(s, OPT_MethodOperand.INTERFACE(meth, false));	    }	  } catch (Exception e) {	      // bogus catch of VM_ResolutionException to keep java happy	      // actually can't be thrown when we pass false for canLoad.	  }	  // Step 2: Invokeinterface requires a dynamic type check	  //         to ensure that the receiver object actually	  //         implements the interface.  This is necessary	  //         because the verifier does not detect incompatible class changes.	  //         If we're building for FastInterfaceInvocation then	  //         this test must be made explicit in the calling sequence.	  //         In the slow interface invocation path, it is handled	  //         deep in the guts of the dispatching code.	  // NOTE:   We don't insert the test here if we are doing to	  //         do a guarded inline of an interface call.  That case	  //         is handled within OPT_Inliner.java.  However, if 	  //         we virtualize the call, we do need to handle the DTC	  //         here, since OPT_Inliner won't have enough information	  //         to determine what the right thing to do is.	  if (requiresImplementsTest) {	    // Attempt to avoid inserting the check by seeing if the 	    // known static type of the receiver implements the interface.	    if (refType.isResolved() && !refType.isInterface()) {	      byte doesImplement = 		OPT_ClassLoaderProxy.includesType(interfaceType, refType);	      requiresImplementsTest = doesImplement != YES;	    }	  }	  // Step 3: Attempt to resolve the interface call to 	  //         a particular virtual method.	  //         Note: step 2 and step 3 are independent	  //         and it is not that case that being able 	  //         to do 2 implies 3 or that doing 3 implies 2.  	  VM_Method vmeth;	  if (refType.isResolved() && !refType.isInterface() &&	      (vmeth=OPT_ClassLoaderProxy.lookupMethod(refType, meth))!=null) {	    // We're going to virtualize it. Must deal with the DTC here.	    if (requiresImplementsTest) {	      appendInstruction(TypeCheck.create(MUST_IMPLEMENT_INTERFACE,						 ref.copyU2U(),						 makeTypeOperand(interfaceType),						 getCurrentGuard()));	    }	    boolean unresolved = OPT_ClassLoaderProxy.needsDynamicLink(vmeth, gc.method.getDeclaringClass());	    Call.setMethod(s, OPT_MethodOperand.VIRTUAL(vmeth, unresolved, true));	    if (gc.options.PRINT_DETAILED_INLINE_REPORT)	      OPT_InlineReport.classUnresolved(unresolved, meth);	    // Think about trying to inline it	    if (!unresolved) {	      // if the type is precise, then we know FOR CERTAIN that	      // this call will resolve to meth	      VM_Method computedTarget = ref.isPreciseType() ? vmeth : null;	      if (computedTarget != null && 		  gc.options.PRINT_DETAILED_INLINE_REPORT)		OPT_InlineReport.isPreciseType();			      OPT_InlineDecision id = 		shouldInline(s, computedTarget, ref.isExtant());              if (maybeInlineMethod(id, s)) {                return;              }	    }	  } else {	    // try to inline a predicted target for the interface invocation            OPT_InlineDecision id = shouldInline(s, null, false);            if (maybeInlineMethod(id, s)) {              return;            } else {	      if (requiresImplementsTest) {		appendInstruction(TypeCheck.create(MUST_IMPLEMENT_INTERFACE,						   ref.copyU2U(),						   makeTypeOperand(interfaceType),						   getCurrentGuard()));	      }	    }	  }	  // CALL must be treated as potential throw of anything	  rectifyStateWithExceptionHandlers(); 	}	break;      case JBC_xxxunusedxxx:	OPT_OptimizingCompilerException.UNREACHABLE();	break;      case JBC_new:	{	  VM_Type klass = bcodes.getTypeReference();	  OPT_TypeOperand klassOp = makeTypeOperand(klass);	  OPT_RegisterOperand t = gc.temps.makeTemp(klass);	  t.setPreciseType();	  markGuardlessNonNull(t);	  OPT_Operator operator;	  if (klass.isInitialized() || klass.asClass().isInBootImage()) {	    operator = NEW;	  } else { 	    operator = NEW_UNRESOLVED;	  }	  s = New.create(operator, t, klassOp);	  push(t.copyD2U());	  rectifyStateWithErrorHandler();	}	break;      case JBC_newarray:	{	  VM_Array array = bcodes.getPrimitiveArrayType().asArray();	  OPT_TypeOperand arrayOp = makeTypeOperand(array);	  OPT_RegisterOperand t = gc.temps.makeTemp(array);	  t.setPreciseType();	  markGuardlessNonNull(t);	  s = NewArray.create(NEWARRAY, t, arrayOp, popInt());	  push(t.copyD2U()); 	  VM_Class et = 	    OPT_ClassLoaderProxy.JavaLangNegativeArraySizeExceptionType;	  rectifyStateWithExceptionHandler(et);	}	break;      case JBC_anewarray:	{	  VM_Type elementTypeRef = bcodes.getTypeReference();	  VM_Array array = elementTypeRef.getArrayTypeForElementType();	  OPT_TypeOperand arrayOp = makeTypeOperand(array);	  OPT_RegisterOperand t = gc.temps.makeTemp(array);	  t.setPreciseType();	  markGuardlessNonNull(t);	  // We can do early resolution of the array type if the element type 	  // is already initialized.	  if (!(array.isInitialized() || array.isInBootImage())) {	    if (elementTypeRef.isInitialized() || elementTypeRef.isInBootImage()) {	      try {		array.load();		array.resolve();		array.instantiate();	      } catch (VM_ResolutionException e) {		// can't raise any errors if the element type is already initialized/or in boot image		if (VM.VerifyAssertions) VM._assert(false); 	      }	    }	  }	  s = NewArray.create(array.isInitialized() ? NEWARRAY : NEWARRAY_UNRESOLVED, 			      t, arrayOp, popInt());	  push(t.copyD2U()); 	  rectifyStateWithErrorHandler();	  VM_Class et = 	    OPT_ClassLoaderProxy.JavaLangNegativeArraySizeExceptionType;	  rectifyStateWithExceptionHandler(et);	}	break;      case JBC_arraylength:	{	  OPT_Operand op1 = pop();	  clearCurrentGuard();	  if (do_NullCheck(op1))	    break;	  if (VM.VerifyAssertions)	    VM._assert(getArrayTypeOf(op1).isArrayType());	  OPT_RegisterOperand t = gc.temps.makeTempInt();	  s = GuardedUnary.create(ARRAYLENGTH, t, op1, getCurrentGuard());	  push(t.copyD2U());	}	break;      case JBC_athrow:	{	  OPT_Operand op0 = pop();	  clearCurrentGuard();	  if (do_NullCheck(op0))	    break;	  VM_Type type = getRefTypeOf(op0);	  if (VM.VerifyAssertions) {	    // fudge to handle conservative approximation of 	    // OPT_ClassLoaderProxy.findCommonSuperclass	    if (type != OPT_ClassLoaderProxy.JavaLangObjectType)	      assertIsAssignable(OPT_ClassLoaderProxy.JavaLangThrowableType, type);	  }	  if (!gc.method.isInterruptible()) {	    // prevent code motion in or out of uninterruptible code sequence	    appendInstruction(Empty.create(UNINT_END));	  }	  endOfBasicBlock = true;	  OPT_BasicBlock definiteTarget = 	    rectifyStateWithExceptionHandler(type, true);	  if (definiteTarget != null) {	    appendInstruction(CacheOp.create(SET_CAUGHT_EXCEPTION, op0));	    s = Goto.create(GOTO, definiteTarget.makeJumpTarget());	  } else {	    s = Athrow.create(ATHROW, (OPT_RegisterOperand)op0);	  }	}	break;      case JBC_checkcast:	{	  VM_Type typeRef = bcodes.getTypeReference();	  boolean classLoading = couldCauseClassLoading(typeRef);	  OPT_TypeOperand typeOp = makeTypeOperand(typeRef);	  OPT_Operand op2 = pop();	  if (VM.VerifyAssertions) VM._assert(op2.isRef());	  if (CF_CHECKCAST && !classLoading) {	    if (op2.isDefinitelyNull()) {	      push(op2);	      if (DBG_CF) db("skipped gen of null checkcast");	      break;	    }	    VM_Type type = getRefTypeOf(op2);  // non-null, null case above	    if (OPT_ClassLoaderProxy.includesType(typeRef,type)==YES){	      push(op2);	      if (DBG_CF)		db("skipped gen of checkcast of " + op2 + " from "		   + typeRef + " to " + type);	      break;	    }	  }	  if (!gc.options.NO_CHECKCAST) {	    if (classLoading) {	      s = TypeCheck.create(CHECKCAST_UNRESOLVED, op2, typeOp);	    } else {	      if (isNonNull(op2)) {		s = TypeCheck.create(CHECKCAST_NOTNULL, op2, typeOp, getGuard(op2));	      } else {		s = TypeCheck.create(CHECKCAST, op2, typeOp);	      }	    }	  }	  op2 = op2.copy();	  if (op2 instanceof OPT_RegisterOperand) {	    ((OPT_RegisterOperand)op2).type = typeRef;	  }	  push(op2);	  VM_Class et = OPT_ClassLoaderProxy.JavaLangClassCastExceptionType;	  rectifyStateWithExceptionHandler(et);	  if (classLoading) rectifyStateWithErrorHandler();	}	break;      case JBC_instanceof:	{	  VM_Type typeRef = bcodes.getTypeReference();	  boolean classLoading = couldCauseClassLoading(typeRef);	  OPT_TypeOperand typeOp = makeTypeOperand(typeRef);	  OPT_Operand op2 = pop();	  if (VM.VerifyAssertions) VM._assert(op2.isRef());	  if (CF_INSTANCEOF && !classLoading) {	    if (op2.isDefinitelyNull()) {	      push(new OPT_IntConstantOperand(0));	      if (DBG_CF) db("skipped gen of null instanceof");	      break;	    }	    VM_Type type = getRefTypeOf(op2);                 // non-null	    int answer = 	      OPT_ClassLoaderProxy.includesType(typeRef, type);	    if (answer == YES && isNonNull(op2)) {	      push(new OPT_IntConstantOperand(1));	      if (DBG_CF)		db("skipped gen of instanceof of " + op2 + " from "		   + typeRef + " to " + type);	      break;	    } else if (answer == NO) {	      push(new OPT_IntConstantOperand(0));	      break;	    }	  }	  OPT_RegisterOperand t = gc.temps.makeTempInt();	  if (classLoading) {	    s = InstanceOf.create(INSTANCEOF_UNRESOLVED, t, typeOp, op2);	  } else {	    if (isNonNull(op2)) {	      s = InstanceOf.create(INSTANCEOF_NOTNULL, t, typeOp, op2, getGuard(op2));	    } else {	      s = InstanceOf.create(INSTANCEOF, t, typeOp, op2);	    } 	  }	  push(t.copyD2U());	  if (classLoading) rectifyStateWithErrorHandler();	}	break;      case JBC_monitorenter:	{	  OPT_Operand op0 = pop();	  clearCurrentGuard();	  if (do_NullCheck(op0))	    break;	  if (VM.VerifyAssertions) VM._assert(op0.isRef());	  if (gc.options.MONITOR_NOP) {	    s = null;	  } else {	    s = MonitorOp.create(MONITORENTER, op0, getCurrentGuard());	  }	}	break;      case JBC_monitorexit:	{	  OPT_Operand op0 = pop();	  clearCurrentGuard();	  if (do_NullCheck(op0))	    break;	  if (gc.options.MONITOR_NOP) {	    s = null;	  } else {	    s = MonitorOp.create(MONITOREXIT, op0, getCurrentGuard());	  }	  VM_Class et =  	    OPT_ClassLoaderProxy.JavaLangIllegalMonitorStateExceptionType;	  rectifyStateWithExceptionHandler(et);	}	break;      case JBC_wide:	{	  int widecode = bcodes.getWideOpcode();	  int index = bcodes.getWideLocalNumber();	  switch (widecode) {	  case JBC_iload:	    s = do_iload(index);	    break;	  case JBC_lload:	    s = do_lload(index);	    break;	  case JBC_fload:	    s = do_fload(index);	    break;	  case JBC_dload:	    s = do_dload(index);	    break;	  case JBC_aload:	    s = do_aload(index);	    break;	  case JBC_istore:	    s = do_store(index, popInt());	    break;	  case JBC_lstore:	    s = do_store(index, popLong());	    break;	  case JBC_fstore:	    s = do_store(index, popFloat());	    break;	  case JBC_dstore:	    s = do_store(index, popDouble());	    break;	  case JBC_astore:	    s = do_astore(index);	    break;	  case JBC_iinc:	    s = do_iinc(index, bcodes.getWideIncrement());	    break;	  case JBC_ret:	    s = _retHelper(index);	    break;	  default:	    OPT_OptimizingCompilerException.UNREACHABLE();	    break;	  }	}	break;      case JBC_multianewarray:	{	  VM_Type arrayType = bcodes.getTypeReference();	  OPT_TypeOperand typeOp = makeTypeOperand(arrayType);	  int dimensions = bcodes.getArrayDimension();	  // Step 1: Create an int array to hold the dimensions.	  OPT_TypeOperand dimArrayType = 	    makeTypeOperand(OPT_ClassLoaderProxy.IntArrayType);	  OPT_RegisterOperand dimArray = 	    gc.temps.makeTemp(OPT_ClassLoaderProxy.IntArrayType);	  markGuardlessNonNull(dimArray);	  dimArray.setPreciseType();	  appendInstruction(NewArray.create(NEWARRAY, dimArray, dimArrayType, 					    new OPT_IntConstantOperand(dimensions)));	  // Step 2: Assign the dimension values to dimArray	  for (int i = dimensions; i > 0; i--) {	    OPT_LocationOperand loc = new OPT_LocationOperand(OPT_ClassLoaderProxy.IntType);	    appendInstruction(AStore.create(INT_ASTORE, popInt(), 					    dimArray.copyD2U(), 					    new OPT_IntConstantOperand(i - 1), 					    loc, new OPT_TrueGuardOperand()));	  }	  // Step 3: Actually create the multiD array	  OPT_RegisterOperand result = gc.temps.makeTemp(arrayType);	  markGuardlessNonNull(result);	  result.setPreciseType();	  appendInstruction(NewArray.create(NEWOBJMULTIARRAY, result, 					    typeOp, dimArray.copyD2U()));	  push(result.copyD2U());	  rectifyStateWithErrorHandler();	  VM_Class et = 	    OPT_ClassLoaderProxy.JavaLangNegativeArraySizeExceptionType;	  rectifyStateWithExceptionHandler(et);	}	break;      case JBC_ifnull:	s = _refIfNullHelper(OPT_ConditionOperand.EQUAL());	break;      case JBC_ifnonnull:	s = _refIfNullHelper(OPT_ConditionOperand.NOT_EQUAL());	break;      case JBC_goto_w:	{	  int offset = bcodes.getWideBranchOffset();	  if (offset != 5)         // skip generating frivolous goto's	    s = _gotoHelper(offset);	}	break;      case JBC_jsr_w:	s = _jsrHelper(bcodes.getWideBranchOffset());	break;	      default:	OPT_OptimizingCompilerException.UNREACHABLE();	break;      }      if (s != null && !currentBBLE.isSelfRegen()) {        appendInstruction(s);      }      // check runoff      if (VM.VerifyAssertions) VM._assert(bcodes.index() <= runoff);      if (!endOfBasicBlock && bcodes.index() == runoff) {        if (DBG_BB || DBG_SELECTED)          db("runoff occurred! current basic block: " + currentBBLE + 	     ", runoff = " + runoff);        endOfBasicBlock = fallThrough = true;      }      if (endOfBasicBlock) {        if (currentBBLE.isSelfRegen()) {          // This block ended in a goto that jumped into the middle of it.          // Through away all out edges from this block, they're out of date          // because we're going to have to regenerate this block.          currentBBLE.block.deleteOut();          if (DBG_CFG || DBG_SELECTED)	    db("Deleted all out edges of " + currentBBLE.block);          return;        }        if (fallThrough) {          if (VM.VerifyAssertions) VM._assert(bcodes.index() < bcodes.length());          // Get/Create fallthrough BBLE and record it as           // currentBBLE's fallThrough.          currentBBLE.fallThrough = getOrCreateBlock(bcodes.index());	  currentBBLE.block.insertOut(currentBBLE.fallThrough.block);        }        return;      }    }   }