System.out.println("**** START OF IR for method: " + ir.method.name + " in class: " + ir.method.getDeclaringClass().getName()); ir.printInstructions(); System.out.println("**** END   OF IR INSTRUCTION DUMP ****");
  void perform(OPT_IR ir) {    // make sure IR info is up-to-date    OPT_DefUse.recomputeSpansBasicBlock(ir);    debugBegining(ir, createGCMaps);    bbLiveInfo = new BBLiveElement[ir.cfg.numberOfNodes()];    for (int i = 0; i < ir.cfg.numberOfNodes(); i++) {      bbLiveInfo[i] = new BBLiveElement();    }    if (createGCMaps) {      // Create the IR-based Map we will use during compilation      // At a later phase this map is converted into the "runtime"      //  map, which is called VM_OptReferenceMap.      map = new OPT_GCIRMap();    }    // allocate the "currentSet" which is used to cache the current results    currentSet = new OPT_LiveSet();    boolean reuseCurrentSet = false;    // make sure reverse top sort order is built	        // currentBlock is the first node in the list     OPT_BasicBlock currentBlock = (OPT_BasicBlock)ir.cfg.buildRevTopSort();    // 2nd parm: true means forward analysis; false means backward analysis    OPT_SortedGraphIterator bbIter = new OPT_SortedGraphIterator(currentBlock, 								 false);    while (currentBlock != null) {      boolean changed = processBlock(currentBlock, reuseCurrentSet, ir);      // mark this block as processed and get the next one      OPT_BasicBlock nextBlock = 	(OPT_BasicBlock)bbIter.markAndGetNextTopSort(changed);      // check to see if nextBlock has only one successor, currentBlock.      // If so, we can reuse the current set and avoid performing a meet.      if (nextBlock != null && 	  bbIter.isSinglePredecessor(currentBlock, nextBlock)) {        reuseCurrentSet = true;      } else {        reuseCurrentSet = false;      }      currentBlock = nextBlock;    }    debugPostGlobal(ir);    // Now compute live ranges, using results from the fixed point computation     // Also, optionally create GC maps    // SSA doesn't need this part so we allow it to be optional.    // However, if we don't perform it than the final maps and intervals aren't    // created, so we can't print them.    if (!skipLocal) {      performLocalPropagation(ir, createGCMaps);      if (createGCMaps && dumpFinalMaps) {        printFinalMaps(ir);      }      if (dumpFinalLiveIntervals) {        printFinalLiveIntervals(ir);      }      // If we performed the local propagation, live interval information       // lives off of each basic block.      // Thus, we no longer need bbLiveInfo (the fixed points results)      // When we don't perform the local propagation, such as translating      // out of SSA, then we need to keep bbLiveInfo around      bbLiveInfo = null;         // compute the mapping from registers to live interval elements      computeRegisterMap(ir);    }    // No longer need currentSet, which is simply a cache of a LiveSet).    currentSet = null;    //-#if JIKESBT    //-#else    // This will be null if createGCMaps is false    if (createGCMaps) {      ir.MIRInfo.gcIRMap = map;    }    //-#endif    // inform the IR that handler liveness is now available    if (storeLiveAtHandlers) {      ir.setHandlerLivenessComputed();    }  }