asm.emitMTLR(T0);
asm.emitMTCTR(T0);
  protected final void emit_invokeinterface(VM_Method methodRef) {    int count = methodRef.getParameterWords() + 1; // +1 for "this" parameter    // (1) Emit dynamic type checking sequence if required to     // do so inline.    if (VM.BuildForIMTInterfaceInvocation || 	(VM.BuildForITableInterfaceInvocation && 	 VM.DirectlyIndexedITables)) {      VM_Method resolvedMethodRef = null;      try {	resolvedMethodRef = methodRef.resolveInterfaceMethod(false);      } catch (VM_ResolutionException e) {	// actually can't be thrown when we pass false for canLoad.      }      if (resolvedMethodRef == null) {	// might be a ghost ref. Call uncommon case typechecking routine 	// to deal with this	asm.emitLtoc(T0, VM_Entrypoints.unresolvedInvokeinterfaceImplementsTestMethod.getOffset());	asm.emitMTLR(T0);	asm.emitLIL (T0, methodRef.getDictionaryId());  // dictionaryId of method we are trying to call	asm.emitL   (T1, (count-1) << 2, SP);           // the "this" object	VM_ObjectModel.baselineEmitLoadTIB(asm,T1,T1);	asm.emitCall(spSaveAreaOffset);                 // throw exception, if link error      } else {	// normal case.  Not a ghost ref.	asm.emitLtoc(T0, VM_Entrypoints.invokeinterfaceImplementsTestMethod.getOffset());	asm.emitMTLR(T0);	asm.emitLtoc(T0, methodRef.getDeclaringClass().getTibOffset()); // tib of the interface method	asm.emitL   (T0, TIB_TYPE_INDEX << 2, T0);                   // type of the interface method	asm.emitL   (T1, (count-1) << 2, SP);                        // the "this" object	VM_ObjectModel.baselineEmitLoadTIB(asm,T1,T1);	asm.emitCall(spSaveAreaOffset);                              // throw exception, if link error      }    }    // (2) Emit interface invocation sequence.    if (VM.BuildForIMTInterfaceInvocation) {      int signatureId = VM_ClassLoader.	findOrCreateInterfaceMethodSignatureId(methodRef.getName(), 					       methodRef.getDescriptor());      int offset      = VM_InterfaceInvocation.getIMTOffset(signatureId);      genMoveParametersToRegisters(true, methodRef); // T0 is "this"      VM_ObjectModel.baselineEmitLoadTIB(asm,S0,T0);      if (VM.BuildForIndirectIMT) {	// Load the IMT base into S0	asm.emitL(S0, TIB_IMT_TIB_INDEX << 2, S0);      }      asm.emitL   (S0, offset, S0);                  // the method address      asm.emitMTLR(S0);      //-#if RVM_WITH_SPECIALIZATION      asm.emitSpecializationCallWithHiddenParameter(spSaveAreaOffset, 						    signatureId, method, 						    biStart);      //-#else      asm.emitCallWithHiddenParameter(spSaveAreaOffset, signatureId);      //-#endif    } else if (VM.BuildForITableInterfaceInvocation && 	       VM.DirectlyIndexedITables && 	       methodRef.getDeclaringClass().isResolved()) {      methodRef = methodRef.resolve();      VM_Class I = methodRef.getDeclaringClass();      genMoveParametersToRegisters(true, methodRef);        //T0 is "this"      VM_ObjectModel.baselineEmitLoadTIB(asm,S0,T0);      asm.emitL   (S0, TIB_ITABLES_TIB_INDEX << 2, S0); // iTables       asm.emitL   (S0, I.getInterfaceId() << 2, S0);  // iTable      asm.emitL   (S0, VM_InterfaceInvocation.getITableIndex(I, methodRef) << 2, S0); // the method to call      asm.emitMTLR(S0);      //-#if RVM_WITH_SPECIALIZATION      asm.emitSpecializationCall(spSaveAreaOffset, method, biStart);      //-#else      asm.emitCall(spSaveAreaOffset);      //-#endif    } else {      VM_Class I = methodRef.getDeclaringClass();      int itableIndex = -1;      if (VM.BuildForITableInterfaceInvocation) {	// get the index of the method in the Itable	if (I.isLoaded()) {	  itableIndex = VM_InterfaceInvocation.getITableIndex(I, methodRef);	}      }      if (itableIndex == -1) {	// itable index is not known at compile-time.	// call "invokeInterface" to resolve object + method id into 	// method address	int methodRefId = methodRef.getDictionaryId();	asm.emitLtoc(T0, VM_Entrypoints.invokeInterfaceMethod.getOffset());	asm.emitMTLR(T0);	asm.emitL   (T0, (count-1) << 2, SP); // object	asm.emitLVAL(T1, methodRefId);        // method id	asm.emitCall(spSaveAreaOffset);       // T0 := resolved method address	asm.emitMTLR(T0);	genMoveParametersToRegisters(true, methodRef);	//-#if RVM_WITH_SPECIALIZATION	asm.emitSpecializationCall(spSaveAreaOffset, method, biStart);	//-#else	asm.emitCall(spSaveAreaOffset);	//-#endif      } else {	// itable index is known at compile-time.	// call "findITable" to resolve object + interface id into 	// itable address	asm.emitLtoc(T0, VM_Entrypoints.findItableMethod.getOffset());	asm.emitMTLR(T0);	asm.emitL   (T0, (count-1) << 2, SP);     // object	VM_ObjectModel.baselineEmitLoadTIB(asm,T0,T0);	asm.emitLVAL(T1, I.getInterfaceId());    // interface id	asm.emitCall(spSaveAreaOffset);   // T0 := itable reference	asm.emitL   (T0, itableIndex << 2, T0); // T0 := the method to call	asm.emitMTLR(T0);	genMoveParametersToRegisters(true, methodRef);        //T0 is "this"	//-#if RVM_WITH_SPECIALIZATION	asm.emitSpecializationCall(spSaveAreaOffset, method, biStart);	//-#else	asm.emitCall(spSaveAreaOffset);	//-#endif      }    }    genPopParametersAndPushReturnValue(true, methodRef);  }