com.oracle.graal.lir.alloc.lsra

Class LinearScanWalker

java.lang.Object

com.oracle.graal.lir.alloc.lsra.IntervalWalker

com.oracle.graal.lir.alloc.lsra.LinearScanWalker

Direct Known Subclasses:

OptimizingLinearScanWalker

class LinearScanWalker
extends IntervalWalker

Field Summary

Fields

Modifier and Type	Field and Description
protected Register[]	availableRegs
protected int[]	blockPos
private static List<Interval>	EMPTY_LIST Only 10% of the lists in spillIntervals are actually used.
private int	maxReg
private int	minReg
private MoveResolver	moveResolver
protected List<Interval>[]	spillIntervals
protected int[]	usePos

Fields inherited from class com.oracle.graal.lir.alloc.lsra.IntervalWalker

activeLists, allocator, currentBinding, currentPosition, inactiveLists, unhandledLists

Constructor Summary

Constructors

Constructor and Description
LinearScanWalker(LinearScan allocator, Interval unhandledFixedFirst, Interval unhandledAnyFirst)

Method Summary

Modifier and Type	Method and Description
protected boolean	activateCurrent(Interval interval) Processes the currentInterval interval in an attempt to allocate a physical register to it and thus allow it to be moved to a list of active intervals.
(package private) boolean	allocFreeRegister(Interval interval)
(package private) void	allocLockedRegister(Interval interval)
(package private) AbstractBlockBase<?>	blockAt(int idx)
(package private) int	blockCount()
(package private) AbstractBlockBase<?>	blockOfOpWithId(int opId)
private void	changeSpillState(Interval interval, int spillPos)
(package private) void	combineSpilledIntervals(Interval interval)
(package private) void	excludeFromUse(Interval i)
(package private) int	findOptimalSplitPos(AbstractBlockBase<?> minBlock, AbstractBlockBase<?> maxBlock, int maxSplitPos)
(package private) int	findOptimalSplitPos(Interval interval, int minSplitPos, int maxSplitPos, boolean doLoopOptimization)
void	finishAllocation()
(package private) void	freeCollectInactiveAny(Interval current)
(package private) void	freeCollectInactiveFixed(Interval current)
(package private) void	freeCollectUnhandled(Interval.RegisterBinding kind, Interval current)
(package private) void	freeExcludeActiveAny()
(package private) void	freeExcludeActiveFixed()
protected void	handleSpillSlot(Interval interval) This is called for every interval that is assigned to a stack slot.
(package private) void	initUseLists(boolean onlyProcessUsePos)
(package private) void	initVarsForAlloc(Interval interval)
(package private) void	insertMove(int operandId, Interval srcIt, Interval dstIt)
(package private) static boolean	isMove(LIRInstruction op, Interval from, Interval to)
(package private) boolean	isRegisterInRange(int reg)
(package private) int	maxRegisterNumber()
(package private) int	minRegisterNumber()
(package private) boolean	noAllocationPossible(Interval interval)
(package private) void	printRegisterState()
(package private) void	setBlockPos(Interval i, int blockPos)
(package private) void	setUsePos(Interval interval, int usePos, boolean onlyProcessUsePos)
(package private) void	spillBlockInactiveFixed(Interval current)
(package private) void	spillBlockUnhandledFixed(Interval current)
(package private) void	spillCollectActiveAny(Interval.RegisterPriority registerPriority)
(package private) void	spillCollectInactiveAny(Interval current)
(package private) void	spillExcludeActiveFixed()
(package private) void	splitAndSpillIntersectingIntervals(Register reg)
(package private) void	splitAndSpillInterval(Interval interval)
(package private) void	splitBeforeUsage(Interval interval, int minSplitPos, int maxSplitPos)
(package private) void	splitForSpilling(Interval interval)
(package private) void	splitStackInterval(Interval interval)
(package private) void	splitWhenPartialRegisterAvailable(Interval interval, int registerAvailableUntil)

Methods inherited from class com.oracle.graal.lir.alloc.lsra.IntervalWalker

removeFromList, walk, walkBefore, walkTo

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

availableRegs

protected Register[] availableRegs

usePos

protected final int[] usePos

blockPos

protected final int[] blockPos

spillIntervals

protected List<Interval>[] spillIntervals

moveResolver

private MoveResolver moveResolver

minReg

private int minReg

maxReg

private int maxReg

EMPTY_LIST

private static final List<Interval> EMPTY_LIST

Only 10% of the lists in spillIntervals are actually used. But when they are used, they can grow quite long. The maximum length observed was 45 (all numbers taken from a bootstrap run of Graal). Therefore, we initialize spillIntervals with this marker value, and allocate a "real" list only on demand in setUsePos(com.oracle.graal.lir.alloc.lsra.Interval, int, boolean).

Constructor Detail

LinearScanWalker

LinearScanWalker(LinearScan allocator,
                 Interval unhandledFixedFirst,
                 Interval unhandledAnyFirst)

Method Detail

blockCount

int blockCount()

blockAt

AbstractBlockBase<?> blockAt(int idx)

blockOfOpWithId

AbstractBlockBase<?> blockOfOpWithId(int opId)

initUseLists

void initUseLists(boolean onlyProcessUsePos)

maxRegisterNumber

int maxRegisterNumber()

minRegisterNumber

int minRegisterNumber()

isRegisterInRange

boolean isRegisterInRange(int reg)

excludeFromUse

void excludeFromUse(Interval i)

setUsePos

void setUsePos(Interval interval,
               int usePos,
               boolean onlyProcessUsePos)

setBlockPos

void setBlockPos(Interval i,
                 int blockPos)

freeExcludeActiveFixed

void freeExcludeActiveFixed()

freeExcludeActiveAny

void freeExcludeActiveAny()

freeCollectInactiveFixed

void freeCollectInactiveFixed(Interval current)

freeCollectInactiveAny

void freeCollectInactiveAny(Interval current)

freeCollectUnhandled

void freeCollectUnhandled(Interval.RegisterBinding kind,
                          Interval current)

spillExcludeActiveFixed

void spillExcludeActiveFixed()

spillBlockUnhandledFixed

void spillBlockUnhandledFixed(Interval current)

spillBlockInactiveFixed

void spillBlockInactiveFixed(Interval current)

spillCollectActiveAny

void spillCollectActiveAny(Interval.RegisterPriority registerPriority)

spillCollectInactiveAny

void spillCollectInactiveAny(Interval current)

insertMove

void insertMove(int operandId,
                Interval srcIt,
                Interval dstIt)

findOptimalSplitPos

int findOptimalSplitPos(AbstractBlockBase<?> minBlock,
                        AbstractBlockBase<?> maxBlock,
                        int maxSplitPos)

findOptimalSplitPos

int findOptimalSplitPos(Interval interval,
                        int minSplitPos,
                        int maxSplitPos,
                        boolean doLoopOptimization)

splitBeforeUsage

void splitBeforeUsage(Interval interval,
                      int minSplitPos,
                      int maxSplitPos)

splitForSpilling

void splitForSpilling(Interval interval)

changeSpillState

private void changeSpillState(Interval interval,
                              int spillPos)

handleSpillSlot

protected void handleSpillSlot(Interval interval)

This is called for every interval that is assigned to a stack slot.

splitStackInterval

void splitStackInterval(Interval interval)

splitWhenPartialRegisterAvailable

void splitWhenPartialRegisterAvailable(Interval interval,
                                       int registerAvailableUntil)

splitAndSpillInterval

void splitAndSpillInterval(Interval interval)

allocFreeRegister

boolean allocFreeRegister(Interval interval)

splitAndSpillIntersectingIntervals

void splitAndSpillIntersectingIntervals(Register reg)

allocLockedRegister

void allocLockedRegister(Interval interval)

printRegisterState

void printRegisterState()

noAllocationPossible

boolean noAllocationPossible(Interval interval)

initVarsForAlloc

void initVarsForAlloc(Interval interval)

isMove

static boolean isMove(LIRInstruction op,
                      Interval from,
                      Interval to)

combineSpilledIntervals

void combineSpilledIntervals(Interval interval)

activateCurrent

protected boolean activateCurrent(Interval interval)

Description copied from class: IntervalWalker

Processes the currentInterval interval in an attempt to allocate a physical register to it and thus allow it to be moved to a list of active intervals.

Overrides:

activateCurrent in class IntervalWalker

Returns:

true if a register was allocated to the currentInterval interval

finishAllocation

public void finishAllocation()