pushInt(T0);
pushAddr(T0);
  private boolean  generateInlineCode(VM_MethodReference methodToBeCalled) {    VM_Atom methodName = methodToBeCalled.getName();          if (methodToBeCalled.getType() == VM_TypeReference.SysCall) {      VM_TypeReference[] args = methodToBeCalled.getParameterTypes();      // (1) Set up arguments according to OS calling convention      int paramWords = methodToBeCalled.getParameterWords();      int gp = FIRST_OS_PARAMETER_GPR;      int fp = FIRST_OS_PARAMETER_FPR;      int stackIndex = paramWords;      for (int i=0; i<args.length; i++) {        VM_TypeReference t = args[i];        if (t.isLongType()) {          stackIndex -= 2;          if (VM.BuildFor64Addr) {            peekLong(gp, gp, stackIndex);            gp++;            } else {          //-#if RVM_FOR_LINUX          /* NOTE: following adjustment is not stated in SVR4 ABI, but            * was implemented in GCC.           */            gp += (gp + 1) & 0x01; // if gpr is even, gpr += 1          //-#endif            peekInt(gp++, stackIndex);      // lo register := lo mem (== hi order word)            peekInt(gp++, stackIndex+1);    // hi register := hi mem (== lo order word)          }        } else if (t.isFloatType()) {          stackIndex -= 1;          peekFloat(fp++, stackIndex);        } else if (t.isDoubleType()) {          stackIndex -= 2;          peekDouble(fp++, stackIndex);        } else if (t.isIntLikeType()) {          stackIndex -= 1;          peekInt(gp++, stackIndex);        } else { // t is object          stackIndex -= 1;          peekAddr(gp++, stackIndex);        }      }      if (VM.VerifyAssertions) {        VM._assert(stackIndex == 0);        // Laziness.  We don't support sysCalls with so         // many arguments that we would have to spill some to the stack.        VM._assert(gp - 1 <= LAST_OS_PARAMETER_GPR);        VM._assert(fp - 1 <= LAST_OS_PARAMETER_FPR);      }      // (2) Call it      int paramBytes = (VM.BuildFor64Addr? args.length : paramWords) * BYTES_IN_STACKSLOT;      VM_Field ip = VM_Entrypoints.getSysCallField(methodName.toString());      generateSysCall(paramBytes, ip);      // (3) Pop Java expression stack      discardSlots(paramWords);      // (4) Push return value (if any)      VM_TypeReference rtype = methodToBeCalled.getReturnType();      if (rtype.isIntLikeType()) {        pushInt(T0);      } else if (rtype.isWordType() || rtype.isReferenceType()) {        pushAddr(T0);       } else if (rtype.isDoubleType()) {        pushDouble(FIRST_OS_PARAMETER_FPR);      } else if (rtype.isFloatType()) {        pushFloat(FIRST_OS_PARAMETER_FPR);      } else if (rtype.isLongType()) {        pushLong(T0, VM.BuildFor64Addr?T0:T1);      }    } else if (methodName == VM_MagicNames.getFramePointer) {      pushAddr(FP);     } else if (methodName == VM_MagicNames.getCallerFramePointer) {      popAddr(T0);                               // pop  frame pointer of callee frame      asm.emitLAddr(T1, STACKFRAME_FRAME_POINTER_OFFSET, T0); // load frame pointer of caller frame      pushAddr(T1);                               // push frame pointer of caller frame    } else if (methodName == VM_MagicNames.setCallerFramePointer) {      popAddr(T1); // value      popAddr(T0); // fp      asm.emitSTAddr(T1,  STACKFRAME_FRAME_POINTER_OFFSET, T0); // *(address+SFPO) := value    } else if (methodName == VM_MagicNames.getCompiledMethodID) {      popAddr(T0);                           // pop  frame pointer of callee frame      asm.emitLInt (T1, STACKFRAME_METHOD_ID_OFFSET, T0); // load compiled method id      pushInt(T1);                           // push method ID     } else if (methodName == VM_MagicNames.setCompiledMethodID) {      popInt(T1); // value      popAddr(T0); // fp      asm.emitSTW(T1,  STACKFRAME_METHOD_ID_OFFSET, T0); // *(address+SNIO) := value    } else if (methodName == VM_MagicNames.getNextInstructionAddress) {      popAddr(T0);                                  // pop  frame pointer of callee frame      asm.emitLAddr(T1, STACKFRAME_NEXT_INSTRUCTION_OFFSET, T0); // load frame pointer of caller frame      pushAddr(T1);                                  // push frame pointer of caller frame    } else if (methodName == VM_MagicNames.setNextInstructionAddress) {      popAddr(T1); // value      popAddr(T0); // fp      asm.emitSTAddr(T1,  STACKFRAME_NEXT_INSTRUCTION_OFFSET, T0); // *(address+SNIO) := value    } else if (methodName == VM_MagicNames.getReturnAddressLocation) {      popAddr(T0);                                  // pop  frame pointer of callee frame      asm.emitLAddr(T1, STACKFRAME_FRAME_POINTER_OFFSET, T0);    // load frame pointer of caller frame      asm.emitADDI (T2, STACKFRAME_NEXT_INSTRUCTION_OFFSET, T1); // get location containing ret addr      pushAddr(T2);                                  // push frame pointer of caller frame    } else if (methodName == VM_MagicNames.getTocPointer ||               methodName == VM_MagicNames.getJTOC) {      pushAddr(JTOC);     } else if (methodName == VM_MagicNames.getProcessorRegister) {      pushAddr(PROCESSOR_REGISTER);    } else if (methodName == VM_MagicNames.setProcessorRegister) {      popAddr(PROCESSOR_REGISTER);    } else if (methodName == VM_MagicNames.getTimeBase) {      if (VM.BuildFor64Addr) {        asm.emitMFTB (T1);      // T1 := time base      } else {        int label = asm.getMachineCodeIndex();        asm.emitMFTBU(T0);                      // T0 := time base, upper        asm.emitMFTB (T1);                      // T1 := time base, lower        asm.emitMFTBU(T2);                      // T2 := time base, upper        asm.emitCMP  (T0, T2);                  // T0 == T2?        asm.emitBC   (NE, label);               // lower rolled over, try again      }      pushLong(T0,T1);                  } else if (methodName == VM_MagicNames.invokeMain) {      popAddr(T0); // t0 := ip      asm.emitMTCTR(T0);      peekAddr(T0,0); // t0 := parameter      asm.emitBCCTRL();          // call      discardSlot(); // pop parameter    } else if (methodName == VM_MagicNames.invokeClassInitializer) {      popAddr(T0); // t0 := address to be called      asm.emitMTCTR(T0);      asm.emitBCCTRL();          // call    } else if (methodName == VM_MagicNames.invokeMethodReturningVoid) {      generateMethodInvocation(); // call method    } else if (methodName == VM_MagicNames.invokeMethodReturningInt) {      generateMethodInvocation(); // call method      pushInt(T0);       // push result    } else if (methodName == VM_MagicNames.invokeMethodReturningLong) {      generateMethodInvocation(); // call method      pushLong(T0, VM.BuildFor64Addr?T0:T1);       // push result    } else if (methodName == VM_MagicNames.invokeMethodReturningFloat) {      generateMethodInvocation(); // call method      pushFloat(F0);     // push result    } else if (methodName == VM_MagicNames.invokeMethodReturningDouble) {      generateMethodInvocation(); // call method      pushDouble(F0);     // push result    } else if (methodName == VM_MagicNames.invokeMethodReturningObject) {      generateMethodInvocation(); // call method      pushAddr(T0);       // push result    } else if (methodName == VM_MagicNames.addressArrayCreate) {      VM_Array type = methodToBeCalled.getType().resolve().asArray();      emit_resolved_newarray(type);    } else if (methodName == VM_MagicNames.addressArrayLength) {      emit_arraylength();    } else if (methodName == VM_MagicNames.addressArrayGet) {      if (VM.BuildFor32Addr || methodToBeCalled.getType() == VM_TypeReference.CodeArray) {        emit_iaload();      } else {        genBoundsCheck();        asm.emitSLDI (T1, T1,  LOG_BYTES_IN_ADDRESS);  // convert index to offset        asm.emitLAddrX(T2, T0, T1);  // load desired array element        pushAddr(T2);      }    } else if (methodName == VM_MagicNames.addressArraySet) {      if (VM.BuildFor32Addr || methodToBeCalled.getType() == VM_TypeReference.CodeArray) {        emit_iastore();        } else {        popAddr(T2);                                   // T2 is value to store        genBoundsCheck();        asm.emitSLDI (T1, T1,  LOG_BYTES_IN_ADDRESS);  // convert index to offset        asm.emitSTAddrX (T2, T0, T1);                  // store value in array      }    } else if (methodName == VM_MagicNames.getIntAtOffset) {       popInt(T1); // pop offset      popAddr(T0); // pop object      asm.emitLIntX (T0, T1, T0); // *(object+offset)      pushInt(T0); // push *(object+offset)    } else if (methodName == VM_MagicNames.getObjectAtOffset ||               methodName == VM_MagicNames.getWordAtOffset ||                methodName == VM_MagicNames.getObjectArrayAtOffset) {      popInt(T1); // pop offset      popAddr(T0); // pop object      asm.emitLAddrX(T0, T1, T0); // *(object+offset)      pushAddr(T0); // push *(object+offset)    } else if (methodName == VM_MagicNames.getByteAtOffset) {      popInt(T1);   // pop offset      popAddr(T0);   // pop object      asm.emitLBZX(T0, T1, T0);   // load byte with zero extension.      pushInt(T0);    // push *(object+offset)     } else if (methodName == VM_MagicNames.getCharAtOffset) {      popInt(T1);   // pop offset      popAddr(T0);   // pop object      asm.emitLHZX(T0, T1, T0);   // load char with zero extension.      pushInt(T0);    // push *(object+offset)     } else if (methodName == VM_MagicNames.setIntAtOffset){      popInt(T2); // pop newvalue      popInt(T1); // pop offset      popAddr(T0); // pop object      asm.emitSTWX(T2, T1, T0); // *(object+offset) = newvalue    } else if (methodName == VM_MagicNames.setObjectAtOffset ||               methodName == VM_MagicNames.setWordAtOffset) {      popAddr(T2); // pop newvalue      popInt(T1); // pop offset      popAddr(T0); // pop object      asm.emitSTAddrX(T2, T1, T0); // *(object+offset) = newvalue    } else if (methodName == VM_MagicNames.setByteAtOffset) {      popInt(T2); // pop newvalue      popInt(T1); // pop offset      popAddr(T0); // pop object      asm.emitSTBX(T2, T1, T0); // *(object+offset) = newvalue    } else if (methodName == VM_MagicNames.setCharAtOffset) {      popInt(T2); // pop newvalue      popInt(T1); // pop offset      popAddr(T0); // pop object      asm.emitSTHX(T2, T1, T0); // *(object+offset) = newvalue    } else if (methodName == VM_MagicNames.getLongAtOffset) {      popInt(T2); // pop offset      popAddr(T1); // pop object      if (VM.BuildFor32Addr) {        asm.emitLWZX (T0, T1, T2); // *(object+offset)        asm.emitADDI(T2, BYTES_IN_INT, T2); // offset += 4        asm.emitLWZX (T1, T1, T2); // *(object+offset+4)      } else {        asm.emitLDX(T1, T1, T2);      }      pushLong(T0,T1);    } else if ((methodName == VM_MagicNames.setLongAtOffset)                || (methodName == VM_MagicNames.setDoubleAtOffset)) {      popLong(T3, T2);        popInt(T1); // pop offset      popAddr(T0); // pop object      if (VM.BuildFor32Addr) {        asm.emitSTWX(T3, T1, T0); // *(object+offset) = newvalue low        asm.emitADDI(T1, BYTES_IN_INT, T1); // offset += 4        asm.emitSTWX(T2, T1, T0); // *(object+offset) = newvalue high      } else {        asm.emitSTDX(T2, T1, T0); // *(object+offset) = newvalue       }     } else if (methodName == VM_MagicNames.getMemoryInt){      popAddr(T0); // address      asm.emitLInt (T0,  0, T0); // *address      pushInt(T0); // *sp := *address    } else if (methodName == VM_MagicNames.getMemoryWord ||               methodName == VM_MagicNames.getMemoryAddress) {      popAddr(T0); // address      asm.emitLAddr(T0,  0, T0); // *address      pushAddr(T0); // *sp := *address    } else if (methodName == VM_MagicNames.setMemoryInt ){      popInt(T1); // value      popAddr(T0); // address      asm.emitSTW(T1,  0, T0); // *address := value    } else if (methodName == VM_MagicNames.setMemoryWord ||               methodName == VM_MagicNames.setMemoryAddress) {      popAddr(T1); // value      popAddr(T0); // address      asm.emitSTAddr(T1,  0, T0); // *address := value    } else if (methodName == VM_MagicNames.prepareInt){      popInt(T1); // pop offset      popAddr(T0); // pop object      if (VM.BuildForSingleVirtualProcessor) {        asm.emitLWZX (T0, T1, T0); // *(object+offset)      } else {        asm.emitLWARX(T0,  T1, T0); // *(object+offset), setting processor's reservation address      } //this Integer is not sign extended !!      pushInt(T0); // push *(object+offset)    } else if (methodName == VM_MagicNames.prepareObject ||               methodName == VM_MagicNames.prepareAddress ||               methodName == VM_MagicNames.prepareWord) {      popInt(T1); // pop offset      popAddr(T0); // pop object      if (VM.BuildForSingleVirtualProcessor) {        asm.emitLAddrX(T0, T1, T0); // *(object+offset)      } else {        if (VM.BuildFor32Addr) {          asm.emitLWARX(T0,  T1, T0); // *(object+offset), setting processor's reservation address        } else {          asm.emitLDARX(T0, T1, T0);        }       }      pushAddr(T0); // push *(object+offset)    } else if (methodName == VM_MagicNames.attemptInt){      popInt(T2);  // pop newValue      discardSlot(); // ignore oldValue      popInt(T1);  // pop offset      popAddr(T0);  // pop object      if (VM.BuildForSingleVirtualProcessor) {        asm.emitSTWX(T2, T1, T0); // store new value (on one VP this succeeds by definition)        asm.emitLVAL(T0,  1);   // T0 := true        pushInt(T0);  // push success of conditional store      } else {        asm.emitSTWCXr(T2,  T1, T0); // store new value and set CR0        asm.emitLVAL(T0,  0);  // T0 := false        VM_ForwardReference fr = asm.emitForwardBC(NE); // skip, if store failed        asm.emitLVAL(T0,  1);   // T0 := true        fr.resolve(asm);        pushInt(T0);  // push success of conditional store      }    } else if (methodName == VM_MagicNames.attemptObject ||               methodName == VM_MagicNames.attemptAddress ||               methodName == VM_MagicNames.attemptWord) {      popAddr(T2);  // pop newValue      discardSlot(); // ignore oldValue      popInt(T1);  // pop offset      popAddr(T0);  // pop object      if (VM.BuildForSingleVirtualProcessor) {        asm.emitSTAddrX(T2,  T1, T0); // store new value (on one VP this succeeds by definition)        asm.emitLVAL(T0,  1);   // T0 := true        pushAddr(T0);  // push success of conditional store      } else {        if (VM.BuildFor32Addr) {          asm.emitSTWCXr(T2,  T1, T0); // store new value and set CR0        } else {          asm.emitSTDCXr(T2,  T1, T0); // store new value and set CR0        }        asm.emitLVAL(T0,  0);  // T0 := false        VM_ForwardReference fr = asm.emitForwardBC(NE); // skip, if store failed        asm.emitLVAL(T0,  1);   // T0 := true        fr.resolve(asm);        pushInt(T0);  // push success of conditional store      }    } else if (methodName == VM_MagicNames.saveThreadState) {      peekAddr(T0, 0); // T0 := address of VM_Registers object      asm.emitLAddrToc(S0, VM_Entrypoints.saveThreadStateInstructionsField.getOffset());      asm.emitMTCTR(S0);      asm.emitBCCTRL(); // call out of line machine code      discardSlot();  // pop arg    } else if (methodName == VM_MagicNames.threadSwitch) {      peekAddr(T1, 0); // T1 := address of VM_Registers of new thread      peekAddr(T0, 1); // T0 := address of previous VM_Thread object      asm.emitLAddrToc(S0, VM_Entrypoints.threadSwitchInstructionsField.getOffset());      asm.emitMTCTR(S0);      asm.emitBCCTRL();      discardSlots(2);  // pop two args    } else if (methodName == VM_MagicNames.restoreHardwareExceptionState) {      peekAddr(T0, 0); // T0 := address of VM_Registers object      asm.emitLAddrToc(S0, VM_Entrypoints.restoreHardwareExceptionStateInstructionsField.getOffset());      asm.emitMTLR(S0);      asm.emitBCLR(); // branch to out of line machine code (does not return)    } else if (methodName == VM_MagicNames.returnToNewStack) {      peekAddr(FP, 0);                                  // FP := new stackframe      asm.emitLAddr(S0, STACKFRAME_NEXT_INSTRUCTION_OFFSET, FP); // fetch...      asm.emitMTLR(S0);                                         // ...return address      asm.emitBCLR ();                                           // return to caller    } else if (methodName == VM_MagicNames.dynamicBridgeTo) {      if (VM.VerifyAssertions) VM._assert(klass.isDynamicBridge());               // fetch parameter (address to branch to) into CT register      //      peekAddr(T0, 0);      asm.emitMTCTR(T0);      // restore volatile and non-volatile registers      // (note that these are only saved for "dynamic bridge" methods)      //      int offset = frameSize;      // restore non-volatile and volatile fprs      for (int i = LAST_NONVOLATILE_FPR; i >= FIRST_VOLATILE_FPR; --i)        asm.emitLFD(i, offset -= BYTES_IN_DOUBLE, FP);            // restore non-volatile gprs      for (int i = LAST_NONVOLATILE_GPR; i >= FIRST_NONVOLATILE_GPR; --i)        asm.emitLAddr(i, offset -= BYTES_IN_ADDRESS, FP);                  // skip saved thread-id, processor, and scratch registers      offset -= (FIRST_NONVOLATILE_GPR - LAST_VOLATILE_GPR - 1) * BYTES_IN_ADDRESS;               // restore volatile gprs      for (int i = LAST_VOLATILE_GPR; i >= FIRST_VOLATILE_GPR; --i)        asm.emitLAddr(i, offset -= BYTES_IN_ADDRESS, FP);                // pop stackframe      asm.emitLAddr(FP, 0, FP);               // restore link register      asm.emitLAddr(S0, STACKFRAME_NEXT_INSTRUCTION_OFFSET, FP);      asm.emitMTLR(S0);      asm.emitBCCTR(); // branch always, through count register    } else if (methodName == VM_MagicNames.objectAsAddress         ||               methodName == VM_MagicNames.addressAsByteArray      ||               methodName == VM_MagicNames.addressAsIntArray       ||               methodName == VM_MagicNames.addressAsObject         ||               methodName == VM_MagicNames.addressAsObjectArray    ||               methodName == VM_MagicNames.addressAsType           ||               methodName == VM_MagicNames.objectAsType            ||               methodName == VM_MagicNames.objectAsByteArray       ||               methodName == VM_MagicNames.objectAsShortArray      ||               methodName == VM_MagicNames.objectAsIntArray        ||               methodName == VM_MagicNames.addressAsThread         ||               methodName == VM_MagicNames.objectAsThread          ||               methodName == VM_MagicNames.objectAsProcessor       ||               methodName == VM_MagicNames.threadAsCollectorThread ||               methodName == VM_MagicNames.addressAsRegisters      ||               methodName == VM_MagicNames.addressAsStack          ||               methodName == VM_MagicNames.floatAsIntBits          ||               methodName == VM_MagicNames.intBitsAsFloat          ||               methodName == VM_MagicNames.doubleAsLongBits        ||               methodName == VM_MagicNames.longBitsAsDouble) {      // no-op (a type change, not a representation change)    } else if (methodName == VM_MagicNames.getObjectType) {      popAddr(T0);                   // get object pointer      VM_ObjectModel.baselineEmitLoadTIB(asm,T0,T0);      asm.emitLAddr(T0,  TIB_TYPE_INDEX << LOG_BYTES_IN_ADDRESS, T0); // get "type" field from type information block      pushAddr(T0);                   // *sp := type    } else if (methodName == VM_MagicNames.getArrayLength) {      popAddr(T0);                   // get object pointer      asm.emitLInt(T0,  VM_ObjectModel.getArrayLengthOffset(), T0); // get array length field      pushInt(T0);                   // *sp := length    } else if (methodName == VM_MagicNames.sync) {      asm.emitSYNC();    } else if (methodName == VM_MagicNames.isync) {      asm.emitISYNC();    } else if (methodName == VM_MagicNames.dcbst) {      popAddr(T0);    // address      asm.emitDCBST(0, T0);    } else if (methodName == VM_MagicNames.icbi) {      popAddr(T0);    // address      asm.emitICBI(0, T0);    } else if (methodName == VM_MagicNames.wordToInt ||                methodName == VM_MagicNames.wordToAddress ||               methodName == VM_MagicNames.wordToOffset ||               methodName == VM_MagicNames.wordToExtent ||               methodName == VM_MagicNames.wordToWord) {      // no-op       } else if (methodName == VM_MagicNames.wordToLong) {      asm.emitLVAL(T0,0);      pushAddr(T0);    } else if (methodName == VM_MagicNames.wordFromInt ||               methodName == VM_MagicNames.wordFromIntSignExtend) {      if (VM.BuildFor64Addr) {        popInt(T0);        pushAddr(T0);      } // else no-op    } else if (methodName == VM_MagicNames.wordFromIntZeroExtend) {      if (VM.BuildFor64Addr) {        asm.emitLWZ(T0, spTopOffset + BYTES_IN_STACKSLOT - BYTES_IN_INT, FP);        pokeAddr(T0,0);      } // else no-op    } else if (methodName == VM_MagicNames.wordFromLong) {      discardSlot();    } else if (methodName == VM_MagicNames.wordAdd) {      if (VM.BuildFor64Addr && (methodToBeCalled.getParameterTypes()[0] == VM_TypeReference.Int)){        popInt(T0);      } else {        popAddr(T0);      }      popAddr(T1);      asm.emitADD (T2, T1, T0);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordSub ||               methodName == VM_MagicNames.wordDiff) {      if (VM.BuildFor64Addr && (methodToBeCalled.getParameterTypes()[0] == VM_TypeReference.Int)){        popInt(T0);                } else {        popAddr(T0);                }      popAddr(T1);      asm.emitSUBFC (T2, T0, T1);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordEQ) {       generateAddrComparison(false, EQ);    } else if (methodName == VM_MagicNames.wordNE) {       generateAddrComparison(false, NE);    } else if (methodName == VM_MagicNames.wordLT) {      generateAddrComparison(false, LT);    } else if (methodName == VM_MagicNames.wordLE) {      generateAddrComparison(false, LE);     } else if (methodName == VM_MagicNames.wordGT) {      generateAddrComparison(false, GT);    } else if (methodName == VM_MagicNames.wordGE) {      generateAddrComparison(false, GE);    } else if (methodName == VM_MagicNames.wordsLT) {      generateAddrComparison(true, LT);    } else if (methodName == VM_MagicNames.wordsLE) {      generateAddrComparison(true, LE);     } else if (methodName == VM_MagicNames.wordsGT) {      generateAddrComparison(true, GT);    } else if (methodName == VM_MagicNames.wordsGE) {      generateAddrComparison(true, GE);    } else if (methodName == VM_MagicNames.wordIsZero) {      // unsigned comparison generating a boolean      asm.emitLVAL(T0,  0);      pushAddr(T0);      generateAddrComparison(false, EQ);    } else if (methodName == VM_MagicNames.wordIsMax) {      // unsigned comparison generating a boolean      asm.emitLVAL(T0, -1);      pushAddr(T0);      generateAddrComparison(false, EQ);    } else if (methodName == VM_MagicNames.wordZero) {      asm.emitLVAL (T0,  0);      pushAddr(T0);    } else if (methodName == VM_MagicNames.wordOne) {      asm.emitLVAL (T0,  1);      pushAddr(T0);    } else if (methodName == VM_MagicNames.wordMax) {      asm.emitLVAL (T0, -1);      pushAddr(T0);    } else if (methodName == VM_MagicNames.wordAnd) {      popAddr(T0);      popAddr(T1);      asm.emitAND(T2, T1, T0);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordOr) {      popAddr(T0);      popAddr(T1);      asm.emitOR (T2, T1, T0);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordNot) {      popAddr(T0);      asm.emitLVAL(T1, -1);      asm.emitXOR(T2, T1, T0);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordXor) {      popAddr(T0);      popAddr(T1);      asm.emitXOR(T2, T1, T0);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordLsh) {      popInt(T0);      popAddr(T1);           asm.emitSLAddr (T2, T1, T0);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordRshl) {      popInt(T0);      popAddr(T1);           asm.emitSRAddr (T2, T1, T0);      pushAddr(T2);    } else if (methodName == VM_MagicNames.wordRsha) {      popInt(T0);      popAddr(T1);           asm.emitSRA_Addr (T2, T1, T0);      pushAddr(T2);    } else {      return false;    }    return true;  }