# HG changeset patch # User Josef Eisl # Date 1431418603 -7200 # Node ID 9ddb5a749eab9b7237ddbc7043aae199ebae58d2 # Parent 88f8bbed600f12844f7ad04e0307eca7b27170fe LinearScan: use multiline comments. diff -r 88f8bbed600f -r 9ddb5a749eab graal/com.oracle.graal.lir/src/com/oracle/graal/lir/alloc/lsra/LinearScan.java --- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/alloc/lsra/LinearScan.java Tue May 12 10:13:06 2015 +0200 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/alloc/lsra/LinearScan.java Tue May 12 10:16:43 2015 +0200 @@ -171,8 +171,10 @@ this.firstVariableNumber = registers.length; this.blockData = new BlockMap<>(ir.getControlFlowGraph()); - // If all allocatable registers are caller saved, then no registers are live across a call - // site. The register allocator can save time not trying to find a register at a call site. + /* + * If all allocatable registers are caller saved, then no registers are live across a call + * site. The register allocator can save time not trying to find a register at a call site. + */ this.callKillsRegisters = regAllocConfig.getRegisterConfig().areAllAllocatableRegistersCallerSaved(); } @@ -265,8 +267,10 @@ } void assignSpillSlot(Interval interval) { - // assign the canonical spill slot of the parent (if a part of the interval - // is already spilled) or allocate a new spill slot + /* + * Assign the canonical spill slot of the parent (if a part of the interval is already + * spilled) or allocate a new spill slot. + */ if (interval.canMaterialize()) { interval.assignLocation(Value.ILLEGAL); } else if (interval.spillSlot() != null) { @@ -458,8 +462,10 @@ int spillLoopDepth = blockForId(spillPos).getLoopDepth(); if (defLoopDepth < spillLoopDepth) { - // the loop depth of the spilling position is higher then the loop depth - // at the definition of the interval . move write to memory out of loop. + /* + * The loop depth of the spilling position is higher then the loop depth at the + * definition of the interval. Move write to memory out of loop. + */ if (Options.LSRAOptimizeSpillPosition.getValue()) { // find best spill position in dominator the tree interval.setSpillState(SpillState.SpillInDominator); @@ -468,8 +474,10 @@ interval.setSpillState(SpillState.StoreAtDefinition); } } else { - // the interval is currently spilled only once, so for now there is no - // reason to store the interval at the definition + /* + * The interval is currently spilled only once, so for now there is no reason to + * store the interval at the definition. + */ interval.setSpillState(SpillState.OneSpillStore); } break; @@ -480,8 +488,7 @@ // the interval is spilled more then once interval.setSpillState(SpillState.SpillInDominator); } else { - // it is better to store it to - // memory at the definition + // It is better to store it to memory at the definition. interval.setSpillState(SpillState.StoreAtDefinition); } break; @@ -526,8 +533,10 @@ void eliminateSpillMoves() { try (Indent indent = Debug.logAndIndent("Eliminating unnecessary spill moves")) { - // collect all intervals that must be stored after their definition. - // the list is sorted by Interval.spillDefinitionPos + /* + * collect all intervals that must be stored after their definition. The list is sorted + * by Interval.spillDefinitionPos. + */ Interval interval; interval = createUnhandledLists(mustStoreAtDefinition, null).first; if (DetailedAsserts.getValue()) { @@ -915,10 +924,11 @@ if (DetailedAsserts.getValue()) { assert ir.getLIRforBlock(fromBlock).get(0) instanceof StandardOp.LabelOp : "block does not start with a label"; - // because the number of predecessor edges matches the number of - // successor edges, blocks which are reached by switch statements - // may have be more than one predecessor but it will be guaranteed - // that all predecessors will be the same. + /* + * Because the number of predecessor edges matches the number of successor edges, + * blocks which are reached by switch statements may have be more than one + * predecessor but it will be guaranteed that all predecessors will be the same. + */ for (AbstractBlockBase predecessor : toBlock.getPredecessors()) { assert fromBlock == predecessor : "all critical edges must be broken"; } @@ -961,9 +971,10 @@ blockCompleted.set(block.getLinearScanNumber()); - // directly resolve between pred and sux (without looking - // at the empty block - // between) + /* + * Directly resolve between pred and sux (without looking at the empty + * block between). + */ resolveCollectMappings(pred, sux, block, moveResolver); if (moveResolver.hasMappings()) { moveResolver.setInsertPosition(instructions, 1); @@ -981,8 +992,10 @@ for (AbstractBlockBase toBlock : fromBlock.getSuccessors()) { - // check for duplicate edges between the same blocks (can happen with switch - // blocks) + /* + * Check for duplicate edges between the same blocks (can happen with switch + * blocks). + */ if (!alreadyResolved.get(toBlock.getLinearScanNumber())) { if (Debug.isLogEnabled()) { Debug.log("processing edge between B%d and B%d", fromBlock.getId(), toBlock.getId()); @@ -1045,8 +1058,10 @@ } } - // operands are not changed when an interval is split during allocation, - // so search the right interval here + /* + * Operands are not changed when an interval is split during allocation, so search the + * right interval here. + */ interval = splitChildAtOpId(interval, opId, mode); } @@ -1062,8 +1077,10 @@ assert interval != null : "interval must exist"; if (opId != -1) { - // operands are not changed when an interval is split during allocation, - // so search the right interval here + /* + * Operands are not changed when an interval is split during allocation, so search the + * right interval here. + */ interval = splitChildAtOpId(interval, opId, mode); } @@ -1077,9 +1094,10 @@ oopIntervals = createUnhandledLists(predicate, null).first; - // intervals that have no oops inside need not to be processed. - // to ensure a walking until the last instruction id, add a dummy interval - // with a high operation id + /* + * Intervals that have no oops inside need not to be processed. to ensure a walking until + * the last instruction id, add a dummy interval with a high operation id. + */ nonOopIntervals = new Interval(Value.ILLEGAL, -1); nonOopIntervals.addRange(Integer.MAX_VALUE - 2, Integer.MAX_VALUE - 1); @@ -1105,12 +1123,14 @@ OperandMode mode = OperandMode.USE; AbstractBlockBase block = blockForId(tempOpId); if (block.getSuccessorCount() == 1 && tempOpId == getLastLirInstructionId(block)) { - // generating debug information for the last instruction of a block. - // if this instruction is a branch, spill moves are inserted before this branch - // and so the wrong operand would be returned (spill moves at block boundaries - // are not - // considered in the live ranges of intervals) - // Solution: use the first opId of the branch target block instead. + /* + * Generating debug information for the last instruction of a block. If this instruction + * is a branch, spill moves are inserted before this branch and so the wrong operand + * would be returned (spill moves at block boundaries are not considered in the live + * ranges of intervals). + * + * Solution: use the first opId of the branch target block instead. + */ final LIRInstruction instr = ir.getLIRforBlock(block).get(ir.getLIRforBlock(block).size() - 1); if (instr instanceof StandardOp.JumpOp) { if (blockData.get(block).liveOut.get(operandNumber(operand))) { @@ -1120,10 +1140,11 @@ } } - // Get current location of operand - // The operand must be live because debug information is considered when building - // the intervals - // if the interval is not live, colorLirOperand will cause an assert on failure + /* + * Get current location of operand. The operand must be live because debug information is + * considered when building the intervals if the interval is not live, colorLirOperand will + * cause an assert on failure. + */ Value result = colorLirOperand((Variable) operand, tempOpId, mode); assert !hasCall(tempOpId) || isStackSlotValue(result) || isConstant(result) || !isCallerSave(result) : "cannot have caller-save register operands at calls"; return result; @@ -1603,14 +1624,18 @@ iw.walkBefore(op.id()); boolean checkLive = true; - // Make sure none of the fixed registers is live across an - // oopmap since we can't handle that correctly. + /* + * Make sure none of the fixed registers is live across an oopmap since we + * can't handle that correctly. + */ if (checkLive) { for (Interval interval = iw.activeLists.get(RegisterBinding.Fixed); interval != Interval.EndMarker; interval = interval.next) { if (interval.currentTo() > op.id() + 1) { - // This interval is live out of this op so make sure - // that this interval represents some value that's - // referenced by this op either as an input or output. + /* + * This interval is live out of this op so make sure that this + * interval represents some value that's referenced by this op + * either as an input or output. + */ checkConsumer.curInterval = interval; checkConsumer.ok = false;