# HG changeset patch # User Josef Eisl # Date 1423239395 -3600 # Node ID f129bb0f4d0fabfe6574686b73aad57778bebcf6 # Parent 16903af7d05c1910a78194e478cd505f64057ee6 Make RedundantMoveElimination a LowLevelLowTierPhase. diff -r 16903af7d05c -r f129bb0f4d0f graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/GraalCompiler.java --- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/GraalCompiler.java Fri Feb 06 17:05:40 2015 +0100 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/GraalCompiler.java Fri Feb 06 17:16:35 2015 +0100 @@ -391,7 +391,7 @@ new EdgeMoveOptimizer().apply(target, lirGenRes, c); ControlFlowOptimizer.optimize(lir, codeEmittingOrder); if (lirGen.canEliminateRedundantMoves()) { - RedundantMoveElimination.optimize(lirGenRes); + new RedundantMoveElimination().apply(target, lirGenRes, c); } NullCheckOptimizer.optimize(target, lirGenRes); diff -r 16903af7d05c -r f129bb0f4d0f graal/com.oracle.graal.lir/src/com/oracle/graal/lir/RedundantMoveElimination.java --- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/RedundantMoveElimination.java Fri Feb 06 17:05:40 2015 +0100 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/RedundantMoveElimination.java Fri Feb 06 17:16:35 2015 +0100 @@ -36,14 +36,16 @@ import com.oracle.graal.lir.StandardOp.MoveOp; import com.oracle.graal.lir.framemap.*; import com.oracle.graal.lir.gen.*; +import com.oracle.graal.lir.phases.*; /** * Removes move instructions, where the destination value is already in place. */ -public final class RedundantMoveElimination { +public final class RedundantMoveElimination extends LowLevelLowTierPhase { - public static void optimize(LIRGenerationResult lirGenRes) { - RedundantMoveElimination redundantMoveElimination = new RedundantMoveElimination(); + @Override + protected void run(TargetDescription target, LIRGenerationResult lirGenRes) { + Optimization redundantMoveElimination = new Optimization(); redundantMoveElimination.doOptimize(lirGenRes.getLIR(), lirGenRes.getFrameMap()); } @@ -58,7 +60,7 @@ * The value numbers also contain information if it is an object kind value or not: if the * number is negative it is an object kind value. */ - private static class BlockData { + private static final class BlockData { BlockData(int stateSize) { entryState = new int[stateSize]; @@ -83,436 +85,440 @@ int entryValueNum; } - Map, BlockData> blockData = CollectionsFactory.newMap(); + private static final class Optimization { - Register[] callerSaveRegs; + Map, BlockData> blockData = CollectionsFactory.newMap(); + + Register[] callerSaveRegs; - /** - * Contains the register number for registers which can be optimized and -1 for the others. - */ - int[] eligibleRegs; + /** + * Contains the register number for registers which can be optimized and -1 for the others. + */ + int[] eligibleRegs; + + Map stackIndices = CollectionsFactory.newMap(); + + int numRegs; + + /* + * Pseudo value for a not yet assigned location. + */ + static final int INIT_VALUE = 0; - Map stackIndices = CollectionsFactory.newMap(); + /** + * The main method doing the elimination of redundant moves. + */ + private void doOptimize(LIR lir, FrameMap frameMap) { - int numRegs; + try (Indent indent = Debug.logAndIndent("eliminate redundant moves")) { + + callerSaveRegs = frameMap.getRegisterConfig().getCallerSaveRegisters(); - /* - * Pseudo value for a not yet assigned location. - */ - static final int INIT_VALUE = 0; + initBlockData(lir); + + // Compute a table of the registers which are eligible for move optimization. + // Unallocatable registers should never be optimized. + eligibleRegs = new int[numRegs]; + Arrays.fill(eligibleRegs, -1); + for (Register reg : frameMap.getRegisterConfig().getAllocatableRegisters()) { + if (reg.number < numRegs) { + eligibleRegs[reg.number] = reg.number; + } + } - /** - * The main method doing the elimination of redundant moves. - */ - private void doOptimize(LIR lir, FrameMap frameMap) { + if (!solveDataFlow(lir)) { + return; + } + + eliminateMoves(lir); + } + } - try (Indent indent = Debug.logAndIndent("eliminate redundant moves")) { + /** + * The maximum number of locations * blocks. This is a complexity limit for the inner loop + * in {@link #mergeState} (assuming a small number of iterations in {@link #solveDataFlow}. + */ + private static final int COMPLEXITY_LIMIT = 30000; - callerSaveRegs = frameMap.getRegisterConfig().getCallerSaveRegisters(); + private void initBlockData(LIR lir) { + + List> blocks = lir.linearScanOrder(); + numRegs = 0; + + int maxStackLocations = COMPLEXITY_LIMIT / blocks.size(); - initBlockData(lir); - - // Compute a table of the registers which are eligible for move optimization. - // Unallocatable registers should never be optimized. - eligibleRegs = new int[numRegs]; - Arrays.fill(eligibleRegs, -1); - for (Register reg : frameMap.getRegisterConfig().getAllocatableRegisters()) { - if (reg.number < numRegs) { - eligibleRegs[reg.number] = reg.number; + /* + * Search for relevant locations which can be optimized. These are register or stack + * slots which occur as destinations of move instructions. + */ + for (AbstractBlock block : blocks) { + List instructions = lir.getLIRforBlock(block); + for (LIRInstruction op : instructions) { + if (isEligibleMove(op)) { + Value dest = ((MoveOp) op).getResult(); + if (isRegister(dest)) { + int regNum = ((RegisterValue) dest).getRegister().number; + if (regNum >= numRegs) { + numRegs = regNum + 1; + } + } else if (isStackSlot(dest)) { + StackSlot stackSlot = (StackSlot) dest; + if (!stackIndices.containsKey(stackSlot) && stackIndices.size() < maxStackLocations) { + stackIndices.put(stackSlot, stackIndices.size()); + } + } + } } } - if (!solveDataFlow(lir)) { - return; + /* + * Now we know the number of locations to optimize, so we can allocate the block states. + */ + int numLocations = numRegs + stackIndices.size(); + Debug.log("num locations = %d (regs = %d, stack = %d)", numLocations, numRegs, stackIndices.size()); + for (AbstractBlock block : blocks) { + BlockData data = new BlockData(numLocations); + blockData.put(block, data); + } + } + + /** + * Calculates the entry and exit states for all basic blocks. + * + * @return Returns true on success and false if the the control flow is too complex. + */ + private boolean solveDataFlow(LIR lir) { + + try (Indent indent = Debug.logAndIndent("solve data flow")) { + + List> blocks = lir.linearScanOrder(); + + int numIter = 0; + + /* + * Iterate until there are no more changes. + */ + int currentValueNum = 1; + boolean firstRound = true; + boolean changed; + do { + changed = false; + try (Indent indent2 = Debug.logAndIndent("new iteration")) { + + for (AbstractBlock block : blocks) { + + BlockData data = blockData.get(block); + /* + * Initialize the number for global value numbering for this block. It + * is essential that the starting number for a block is consistent at + * all iterations and also in eliminateMoves(). + */ + if (firstRound) { + data.entryValueNum = currentValueNum; + } + int valueNum = data.entryValueNum; + assert valueNum > 0; + boolean newState = false; + + if (block == blocks.get(0) || block.isExceptionEntry()) { + /* + * The entry block has undefined values. And also exception handler + * blocks: the LinearScan can insert moves at the end of an + * exception handler predecessor block (after the invoke, which + * throws the exception), and in reality such moves are not in the + * control flow in case of an exception. So we assume a save default + * for exception handler blocks. + */ + Debug.log("kill all values at entry of block %d", block.getId()); + clearValues(data.entryState, valueNum); + } else { + /* + * Merge the states of predecessor blocks + */ + for (AbstractBlock predecessor : block.getPredecessors()) { + BlockData predData = blockData.get(predecessor); + newState |= mergeState(data.entryState, predData.exitState, valueNum); + } + } + // Advance by the value numbers which are "consumed" by + // clearValues and mergeState + valueNum += data.entryState.length; + + if (newState || firstRound) { + try (Indent indent3 = Debug.logAndIndent("update block %d", block.getId())) { + + /* + * Derive the exit state from the entry state by iterating + * through all instructions of the block. + */ + int[] iterState = data.exitState; + copyState(iterState, data.entryState); + List instructions = lir.getLIRforBlock(block); + + for (LIRInstruction op : instructions) { + valueNum = updateState(iterState, op, valueNum); + } + changed = true; + } + } + if (firstRound) { + currentValueNum = valueNum; + } + } + firstRound = false; + } + numIter++; + + if (numIter > 5) { + /* + * This is _very_ seldom. + */ + return false; + } + + } while (changed); + } - eliminateMoves(lir); + return true; } - } + + /** + * Deletes all move instructions where the target location already contains the source + * value. + */ + private void eliminateMoves(LIR lir) { + + try (Indent indent = Debug.logAndIndent("eliminate moves")) { - /** - * The maximum number of locations * blocks. This is a complexity limit for the inner loop in - * {@link #mergeState} (assuming a small number of iterations in {@link #solveDataFlow}. - */ - private static final int COMPLEXITY_LIMIT = 30000; + List> blocks = lir.linearScanOrder(); + + for (AbstractBlock block : blocks) { + + try (Indent indent2 = Debug.logAndIndent("eliminate moves in block %d", block.getId())) { - private void initBlockData(LIR lir) { + List instructions = lir.getLIRforBlock(block); + BlockData data = blockData.get(block); + boolean hasDead = false; - List> blocks = lir.linearScanOrder(); - numRegs = 0; - - int maxStackLocations = COMPLEXITY_LIMIT / blocks.size(); + // Reuse the entry state for iteration, we don't need it later. + int[] iterState = data.entryState; - /* - * Search for relevant locations which can be optimized. These are register or stack slots - * which occur as destinations of move instructions. - */ - for (AbstractBlock block : blocks) { - List instructions = lir.getLIRforBlock(block); - for (LIRInstruction op : instructions) { - if (isEligibleMove(op)) { - Value dest = ((MoveOp) op).getResult(); - if (isRegister(dest)) { - int regNum = ((RegisterValue) dest).getRegister().number; - if (regNum >= numRegs) { - numRegs = regNum + 1; + // Add the values which are "consumed" by clearValues and + // mergeState in solveDataFlow + int valueNum = data.entryValueNum + data.entryState.length; + + int numInsts = instructions.size(); + for (int idx = 0; idx < numInsts; idx++) { + LIRInstruction op = instructions.get(idx); + if (isEligibleMove(op)) { + MoveOp moveOp = (MoveOp) op; + int sourceIdx = getStateIdx(moveOp.getInput()); + int destIdx = getStateIdx(moveOp.getResult()); + if (sourceIdx >= 0 && destIdx >= 0 && iterState[sourceIdx] == iterState[destIdx]) { + assert iterState[sourceIdx] != INIT_VALUE; + Debug.log("delete move %s", op); + instructions.set(idx, null); + hasDead = true; + } + } + // It doesn't harm if updateState is also called for a deleted move + valueNum = updateState(iterState, op, valueNum); } - } else if (isStackSlot(dest)) { - StackSlot stackSlot = (StackSlot) dest; - if (!stackIndices.containsKey(stackSlot) && stackIndices.size() < maxStackLocations) { - stackIndices.put(stackSlot, stackIndices.size()); + if (hasDead) { + instructions.removeAll(Collections.singleton(null)); } } } } } - /* - * Now we know the number of locations to optimize, so we can allocate the block states. + /** + * Updates the state for one instruction. */ - int numLocations = numRegs + stackIndices.size(); - Debug.log("num locations = %d (regs = %d, stack = %d)", numLocations, numRegs, stackIndices.size()); - for (AbstractBlock block : blocks) { - BlockData data = new BlockData(numLocations); - blockData.put(block, data); - } - } - - /** - * Calculates the entry and exit states for all basic blocks. - * - * @return Returns true on success and false if the the control flow is too complex. - */ - private boolean solveDataFlow(LIR lir) { - - try (Indent indent = Debug.logAndIndent("solve data flow")) { - - List> blocks = lir.linearScanOrder(); + private int updateState(final int[] state, LIRInstruction op, int initValueNum) { - int numIter = 0; + try (final Indent indent = Debug.logAndIndent("update state for op %s, initial value num = %d", op, initValueNum)) { + if (isEligibleMove(op)) { + /* + * Handle the special case of a move instruction + */ + MoveOp moveOp = (MoveOp) op; + int sourceIdx = getStateIdx(moveOp.getInput()); + int destIdx = getStateIdx(moveOp.getResult()); + if (sourceIdx >= 0 && destIdx >= 0) { + assert isObjectValue(state[sourceIdx]) || moveOp.getInput().getLIRKind().isValue() : "move op moves object but input is not defined as object"; + state[destIdx] = state[sourceIdx]; + Debug.log("move value %d from %d to %d", state[sourceIdx], sourceIdx, destIdx); + return initValueNum; + } + } - /* - * Iterate until there are no more changes. - */ - int currentValueNum = 1; - boolean firstRound = true; - boolean changed; - do { - changed = false; - try (Indent indent2 = Debug.logAndIndent("new iteration")) { + int valueNum = initValueNum; + + if (op.destroysCallerSavedRegisters()) { + Debug.log("kill all caller save regs"); - for (AbstractBlock block : blocks) { - - BlockData data = blockData.get(block); - /* - * Initialize the number for global value numbering for this block. It is - * essential that the starting number for a block is consistent at all - * iterations and also in eliminateMoves(). - */ - if (firstRound) { - data.entryValueNum = currentValueNum; + for (Register reg : callerSaveRegs) { + if (reg.number < numRegs) { + // Kind.Object is the save default + state[reg.number] = encodeValueNum(valueNum++, true); } - int valueNum = data.entryValueNum; - assert valueNum > 0; - boolean newState = false; + } + } + + /* + * Value procedure for the instruction's output and temp values + */ + class OutputValueConsumer implements ValueConsumer { - if (block == blocks.get(0) || block.isExceptionEntry()) { + int opValueNum; + + OutputValueConsumer(int opValueNum) { + this.opValueNum = opValueNum; + } + + @Override + public void visitValue(Value operand, OperandMode mode, EnumSet flags) { + int stateIdx = getStateIdx(operand); + if (stateIdx >= 0) { /* - * The entry block has undefined values. And also exception handler - * blocks: the LinearScan can insert moves at the end of an exception - * handler predecessor block (after the invoke, which throws the - * exception), and in reality such moves are not in the control flow in - * case of an exception. So we assume a save default for exception - * handler blocks. - */ - Debug.log("kill all values at entry of block %d", block.getId()); - clearValues(data.entryState, valueNum); - } else { - /* - * Merge the states of predecessor blocks + * Assign a unique number to the output or temp location. */ - for (AbstractBlock predecessor : block.getPredecessors()) { - BlockData predData = blockData.get(predecessor); - newState |= mergeState(data.entryState, predData.exitState, valueNum); - } - } - // Advance by the value numbers which are "consumed" by - // clearValues and mergeState - valueNum += data.entryState.length; - - if (newState || firstRound) { - try (Indent indent3 = Debug.logAndIndent("update block %d", block.getId())) { - - /* - * Derive the exit state from the entry state by iterating through - * all instructions of the block. - */ - int[] iterState = data.exitState; - copyState(iterState, data.entryState); - List instructions = lir.getLIRforBlock(block); - - for (LIRInstruction op : instructions) { - valueNum = updateState(iterState, op, valueNum); - } - changed = true; - } - } - if (firstRound) { - currentValueNum = valueNum; + state[stateIdx] = encodeValueNum(opValueNum++, !operand.getLIRKind().isValue()); + Debug.log("set def %d for register %s(%d): %d", opValueNum, operand, stateIdx, state[stateIdx]); } } - firstRound = false; - } - numIter++; - - if (numIter > 5) { - /* - * This is _very_ seldom. - */ - return false; } - } while (changed); + OutputValueConsumer outputValueConsumer = new OutputValueConsumer(valueNum); + + op.visitEachTemp(outputValueConsumer); + /* + * Semantically the output values are written _after_ the temp values + */ + op.visitEachOutput(outputValueConsumer); + + valueNum = outputValueConsumer.opValueNum; + if (op.hasState()) { + /* + * All instructions with framestates (mostly method calls), may do garbage + * collection. GC will rewrite all object references which are live at this + * point. So we can't rely on their values. It would be sufficient to just kill + * all values which are referenced in the state (or all values which are not), + * but for simplicity we kill all values. + */ + Debug.log("kill all object values"); + clearValuesOfKindObject(state, valueNum); + valueNum += state.length; + } + + return valueNum; + } } - return true; - } - - /** - * Deletes all move instructions where the target location already contains the source value. - */ - private void eliminateMoves(LIR lir) { - - try (Indent indent = Debug.logAndIndent("eliminate moves")) { - - List> blocks = lir.linearScanOrder(); - - for (AbstractBlock block : blocks) { - - try (Indent indent2 = Debug.logAndIndent("eliminate moves in block %d", block.getId())) { - - List instructions = lir.getLIRforBlock(block); - BlockData data = blockData.get(block); - boolean hasDead = false; - - // Reuse the entry state for iteration, we don't need it later. - int[] iterState = data.entryState; + /** + * The state merge function for dataflow joins. + */ + private static boolean mergeState(int[] dest, int[] source, int defNum) { + assert dest.length == source.length; + boolean changed = false; + for (int idx = 0; idx < source.length; idx++) { + int phiNum = defNum + idx; + int dst = dest[idx]; + int src = source[idx]; + if (dst != src && src != INIT_VALUE && dst != encodeValueNum(phiNum, isObjectValue(dst))) { + if (dst != INIT_VALUE) { + dst = encodeValueNum(phiNum, isObjectValue(dst) || isObjectValue(src)); + } else { + dst = src; + } + dest[idx] = dst; + changed = true; + } + } + return changed; + } - // Add the values which are "consumed" by clearValues and - // mergeState in solveDataFlow - int valueNum = data.entryValueNum + data.entryState.length; + private static void copyState(int[] dest, int[] source) { + assert dest.length == source.length; + for (int idx = 0; idx < source.length; idx++) { + dest[idx] = source[idx]; + } + } - int numInsts = instructions.size(); - for (int idx = 0; idx < numInsts; idx++) { - LIRInstruction op = instructions.get(idx); - if (isEligibleMove(op)) { - MoveOp moveOp = (MoveOp) op; - int sourceIdx = getStateIdx(moveOp.getInput()); - int destIdx = getStateIdx(moveOp.getResult()); - if (sourceIdx >= 0 && destIdx >= 0 && iterState[sourceIdx] == iterState[destIdx]) { - assert iterState[sourceIdx] != INIT_VALUE; - Debug.log("delete move %s", op); - instructions.set(idx, null); - hasDead = true; - } - } - // It doesn't harm if updateState is also called for a deleted move - valueNum = updateState(iterState, op, valueNum); - } - if (hasDead) { - instructions.removeAll(Collections.singleton(null)); - } + private static void clearValues(int[] state, int defNum) { + for (int idx = 0; idx < state.length; idx++) { + int phiNum = defNum + idx; + // Let the killed values assume to be object references: it's the save default. + state[idx] = encodeValueNum(phiNum, true); + } + } + + private static void clearValuesOfKindObject(int[] state, int defNum) { + for (int idx = 0; idx < state.length; idx++) { + int phiNum = defNum + idx; + if (isObjectValue(state[idx])) { + state[idx] = encodeValueNum(phiNum, true); } } } - } - /** - * Updates the state for one instruction. - */ - private int updateState(final int[] state, LIRInstruction op, int initValueNum) { - - try (final Indent indent = Debug.logAndIndent("update state for op %s, initial value num = %d", op, initValueNum)) { - if (isEligibleMove(op)) { - /* - * Handle the special case of a move instruction - */ - MoveOp moveOp = (MoveOp) op; - int sourceIdx = getStateIdx(moveOp.getInput()); - int destIdx = getStateIdx(moveOp.getResult()); - if (sourceIdx >= 0 && destIdx >= 0) { - assert isObjectValue(state[sourceIdx]) || moveOp.getInput().getLIRKind().isValue() : "move op moves object but input is not defined as object"; - state[destIdx] = state[sourceIdx]; - Debug.log("move value %d from %d to %d", state[sourceIdx], sourceIdx, destIdx); - return initValueNum; + /** + * Returns the index to the state arrays in BlockData for a specific location. + */ + private int getStateIdx(Value location) { + if (isRegister(location)) { + int regNum = ((RegisterValue) location).getRegister().number; + if (regNum < numRegs) { + return eligibleRegs[regNum]; } - } - - int valueNum = initValueNum; - - if (op.destroysCallerSavedRegisters()) { - Debug.log("kill all caller save regs"); - - for (Register reg : callerSaveRegs) { - if (reg.number < numRegs) { - // Kind.Object is the save default - state[reg.number] = encodeValueNum(valueNum++, true); - } - } - } - - /* - * Value procedure for the instruction's output and temp values - */ - class OutputValueConsumer implements ValueConsumer { - - int opValueNum; - - OutputValueConsumer(int opValueNum) { - this.opValueNum = opValueNum; - } - - @Override - public void visitValue(Value operand, OperandMode mode, EnumSet flags) { - int stateIdx = getStateIdx(operand); - if (stateIdx >= 0) { - /* - * Assign a unique number to the output or temp location. - */ - state[stateIdx] = encodeValueNum(opValueNum++, !operand.getLIRKind().isValue()); - Debug.log("set def %d for register %s(%d): %d", opValueNum, operand, stateIdx, state[stateIdx]); - } - } + return -1; } - - OutputValueConsumer outputValueConsumer = new OutputValueConsumer(valueNum); - - op.visitEachTemp(outputValueConsumer); - /* - * Semantically the output values are written _after_ the temp values - */ - op.visitEachOutput(outputValueConsumer); - - valueNum = outputValueConsumer.opValueNum; - - if (op.hasState()) { - /* - * All instructions with framestates (mostly method calls), may do garbage - * collection. GC will rewrite all object references which are live at this point. - * So we can't rely on their values. It would be sufficient to just kill all values - * which are referenced in the state (or all values which are not), but for - * simplicity we kill all values. - */ - Debug.log("kill all object values"); - clearValuesOfKindObject(state, valueNum); - valueNum += state.length; - } - - return valueNum; - } - } - - /** - * The state merge function for dataflow joins. - */ - private static boolean mergeState(int[] dest, int[] source, int defNum) { - assert dest.length == source.length; - boolean changed = false; - for (int idx = 0; idx < source.length; idx++) { - int phiNum = defNum + idx; - int dst = dest[idx]; - int src = source[idx]; - if (dst != src && src != INIT_VALUE && dst != encodeValueNum(phiNum, isObjectValue(dst))) { - if (dst != INIT_VALUE) { - dst = encodeValueNum(phiNum, isObjectValue(dst) || isObjectValue(src)); - } else { - dst = src; + if (isStackSlot(location)) { + StackSlot slot = (StackSlot) location; + Integer index = stackIndices.get(slot); + if (index != null) { + return index.intValue() + numRegs; } - dest[idx] = dst; - changed = true; - } - } - return changed; - } - - private static void copyState(int[] dest, int[] source) { - assert dest.length == source.length; - for (int idx = 0; idx < source.length; idx++) { - dest[idx] = source[idx]; - } - } - - private static void clearValues(int[] state, int defNum) { - for (int idx = 0; idx < state.length; idx++) { - int phiNum = defNum + idx; - // Let the killed values assume to be object references: it's the save default. - state[idx] = encodeValueNum(phiNum, true); - } - } - - private static void clearValuesOfKindObject(int[] state, int defNum) { - for (int idx = 0; idx < state.length; idx++) { - int phiNum = defNum + idx; - if (isObjectValue(state[idx])) { - state[idx] = encodeValueNum(phiNum, true); - } - } - } - - /** - * Returns the index to the state arrays in BlockData for a specific location. - */ - private int getStateIdx(Value location) { - if (isRegister(location)) { - int regNum = ((RegisterValue) location).getRegister().number; - if (regNum < numRegs) { - return eligibleRegs[regNum]; } return -1; } - if (isStackSlot(location)) { - StackSlot slot = (StackSlot) location; - Integer index = stackIndices.get(slot); - if (index != null) { - return index.intValue() + numRegs; + + /** + * Encodes a value number + the is-object information to a number to be stored in a state. + */ + private static int encodeValueNum(int valueNum, boolean isObjectKind) { + assert valueNum > 0; + if (isObjectKind) { + return -valueNum; } + return valueNum; } - return -1; - } - - /** - * Encodes a value number + the is-object information to a number to be stored in a state. - */ - private static int encodeValueNum(int valueNum, boolean isObjectKind) { - assert valueNum > 0; - if (isObjectKind) { - return -valueNum; - } - return valueNum; - } - /** - * Returns true if an encoded value number (which is stored in a state) refers to an object - * reference. - */ - private static boolean isObjectValue(int encodedValueNum) { - return encodedValueNum < 0; - } + /** + * Returns true if an encoded value number (which is stored in a state) refers to an object + * reference. + */ + private static boolean isObjectValue(int encodedValueNum) { + return encodedValueNum < 0; + } - /** - * Returns true for a move instruction which is a candidate for elimination. - */ - private static boolean isEligibleMove(LIRInstruction op) { - if (op instanceof MoveOp) { - MoveOp moveOp = (MoveOp) op; - Value source = moveOp.getInput(); - Value dest = moveOp.getResult(); - /* - * Moves with mismatching kinds are not moves, but memory loads/stores! - */ - return source.getLIRKind().equals(dest.getLIRKind()); + /** + * Returns true for a move instruction which is a candidate for elimination. + */ + private static boolean isEligibleMove(LIRInstruction op) { + if (op instanceof MoveOp) { + MoveOp moveOp = (MoveOp) op; + Value source = moveOp.getInput(); + Value dest = moveOp.getResult(); + /* + * Moves with mismatching kinds are not moves, but memory loads/stores! + */ + return source.getLIRKind().equals(dest.getLIRKind()); + } + return false; } - return false; } }