VM.assert(Call.getAddress(s) == null,
VM._assert(Call.getAddress(s) == null,
  static OPT_Instruction call (OPT_Instruction s, OPT_IR ir) {    OPT_MethodOperand methOp = Call.getMethod(s);    boolean unresolved = false;    if (methOp != null && methOp.unresolved) {      unresolved = true;      if (VM.VerifyAssertions)	VM.assert(Call.getAddress(s) == null, 		  "Unresolved call with InstrAddr?");      OPT_RegisterOperand instrAddr = 	ir.regpool.makeTemp(OPT_ClassLoaderProxy.InstructionArrayType);      OPT_Operand offset;      OPT_LocationOperand loc = new OPT_LocationOperand(methOp);      switch (methOp.type) {      case OPT_MethodOperand.SPECIAL:	// See the comments in VM_OptLinker.java.	// Only a subset of the functionality is actually required.	{	  // the <init> methods can't possibly be a dummy ref, so 	  // it should be safe to use the unguarded references.	  offset = resolve(methOp, s, ir, true);	  OPT_Instruction ia_load = Load.create(REF_LOAD, instrAddr, 						ir.regpool.makeJTOCOp(ir,s), 						offset, loc);	  s.insertBefore(ia_load);	}	break;      case OPT_MethodOperand.STATIC:	{	  offset = resolve(methOp, s, ir, false);	  OPT_Instruction ia_load = Load.create(REF_LOAD, instrAddr, 						ir.regpool.makeJTOCOp(ir,s), 						offset, loc);	  s.insertBefore(ia_load);	}	break;      case OPT_MethodOperand.VIRTUAL:	{	  // NOTE: Because BC2IR is (incorrectly) inserting 	  // a nullcheck before all invokevirtuals, we know that the	  // receiver is non-null, therefore an object allocation has 	  // occured that forced any necessary classloading, 	  // therefore the offset must be valid.  	  // BUT, this does not comply with the JVM spec.  	  // BC2IR should not be inserting the nullcheck for an unresolved	  // invokevirtual because we are required to throw 	  // classloading/linking exceptions even if the receiver is null.  	  // But, for now we ignore this silly aspect of the spec.	  // (see def of invokevirtual in JVM spec)	  // 	  // TODO: However as a short-term fix for dynamic linking with	  //       dummy references we pretend the offset might actually	  //       be invalid to give us an easy hook to resolve the 	  //       reference and find the real field declaration.	  offset = resolve(methOp, s, ir, false);	  OPT_Instruction ia_load = 	    Load.create(REF_LOAD, instrAddr, 			getTIB(s, ir, 			       Call.getParam(s, 0).copy(),			       Call.getGuard(s).copy()), 			offset, loc);	  s.insertBefore(ia_load);	}	break;      }      // it will be resolved by the time the call is executed.      methOp.unresolved = false;       Call.setAddress(s, instrAddr.copyD2U());    }    s = _callHelper(s, ir);    return  s;  }