Interval (Graal OpenJDK Project Documentation)

java.lang.Object
- com.oracle.graal.lir.alloc.lsra.Interval

```
public final class Interval
extends Object
```
Represents an interval in the linear scan register allocator.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) static class`	`Interval.Pair` A pair of intervals.
`(package private) static class`	`Interval.RegisterBinding` Constants denoting whether an interval is bound to a specific register.
`(package private) static class`	`Interval.RegisterBindingLists` A set of interval lists, one per binding type.
`static class`	`Interval.RegisterPriority` Constants denoting the register usage priority for an interval.
`static class`	`Interval.SpillState` Constants used in optimization of spilling of an interval.
`(package private) static class`	`Interval.State` Constants denoting the linear-scan states an interval may be in with respect to the start `position` of the interval being processed.
`static class`	`Interval.UsePosList` List of use positions.

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`cachedTo`
`private Range`	`current` Iterator used to traverse the ranges of an interval.
`private Interval`	`currentSplitChild` Current split child that has been active or inactive last (always stored in split parents).
`(package private) static Interval`	`EndMarker` Sentinel interval to denote the end of an interval list.
`private Range`	`first` The head of the list of ranges describing this interval.
`private boolean`	`insertMoveWhenActivated` Specifies if move is inserted between currentSplitChild and this interval when interval gets active the first time.
`private LIRKind`	`kind` The kind of this interval.
`private AllocatableValue`	`location` The register or spill slot assigned to this interval.
`private Interval`	`locationHint` This interval should be assigned the same location as the hint interval.
`private JavaConstant`	`materializedValue` The value with which a spilled child interval can be re-materialized.
`(package private) Interval`	`next` Link to next interval in a sorted list of intervals that ends with `EndMarker`.
`private int`	`numMaterializationValuesAdded` The number of times `addMaterializationValue(JavaConstant)` is called.
`AllocatableValue`	`operand` The register or variable for this interval prior to register allocation.
`int`	`operandNumber` The operand number for this interval's operand.
`private int`	`spillDefinitionPos` Position where this interval is defined (if defined only once).
`private StackSlotValue`	`spillSlot` The stack slot to which all splits of this interval are spilled if necessary.
`private Interval.SpillState`	`spillState` For spill move optimization.
`private List<Interval>`	`splitChildren` List of all intervals that are split off from this interval.
`private Interval`	`splitParent` The interval from which this one is derived.
`(package private) Interval.State`	`state` The linear-scan state of this interval.
`private Interval.UsePosList`	`usePosList` List of (use-positions, register-priorities) pairs, sorted by use-positions.

Constructor Summary

Constructors
Constructor and Description

Interval(AllocatableValue operand, int operandNumber)

Constructors
Constructor and Description
`Interval(AllocatableValue operand, int operandNumber)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private Interval.RegisterPriority`	`adaptPriority(Interval.RegisterPriority priority)`
`void`	`addMaterializationValue(JavaConstant value)` Sets the value which is used for re-materialization.
`void`	`addRange(int from, int to)`
`void`	`addUsePos(int pos, Interval.RegisterPriority registerPriority)`
`boolean`	`alwaysInMemory()`
`(package private) void`	`assignLocation(AllocatableValue newLocation)`
`(package private) int`	`calcTo()`
`boolean`	`canMaterialize()` Returns true if this interval can be re-materialized when spilled.
`private boolean`	`checkSplitChild(Interval result, int opId, LinearScan allocator, int toOffset, LIRInstruction.OperandMode mode)`
`(package private) boolean`	`checkSplitChildren()`
`(package private) boolean`	`covers(int opId, LIRInstruction.OperandMode mode)`
`(package private) boolean`	`currentAtEnd()`
`(package private) int`	`currentFrom()`
`(package private) boolean`	`currentIntersects(Interval it)`
`(package private) int`	`currentIntersectsAt(Interval it)`
`(package private) Interval`	`currentSplitChild()`
`(package private) int`	`currentTo()`
`Range`	`first()`
`(package private) int`	`firstUsage(Interval.RegisterPriority minRegisterPriority)`
`int`	`from()`
`(package private) Interval`	`getIntervalCoveringOpId(int opId)`
`JavaConstant`	`getMaterializedValue()` Returns a value which can be moved to a register instead of a restore-move from stack.
`(package private) Interval`	`getSplitChildAtOpId(int opId, LIRInstruction.OperandMode mode, LinearScan allocator)`
`(package private) Interval`	`getSplitChildBeforeOpId(int opId)`
`(package private) List<Interval>`	`getSplitChildren()`
`(package private) boolean`	`hasHoleBetween(int holeFrom, int holeTo)`
`(package private) boolean`	`insertMoveWhenActivated()`
`(package private) boolean`	`intersects(Interval i)`
`(package private) int`	`intersectsAt(Interval i)`
`(package private) boolean`	`isSplitChild()`
`boolean`	`isSplitParent()`
`LIRKind`	`kind()`
`AllocatableValue`	`location()` Gets the register or spill slot assigned to this interval.
`Interval`	`locationHint(boolean searchSplitChild)`
`String`	`logString(LinearScan allocator)` Gets a single line string for logging the details of this interval to a log stream.
`(package private) void`	`makeCurrentSplitChild()`
`(package private) Interval`	`newSplitChild(LinearScan allocator)`
`(package private) void`	`nextRange()`
`(package private) int`	`nextUsage(Interval.RegisterPriority minRegisterPriority, int from)`
`(package private) int`	`nextUsageExact(Interval.RegisterPriority exactRegisterPriority, int from)`
`(package private) int`	`numUsePositions()`
`(package private) int`	`previousUsage(Interval.RegisterPriority minRegisterPriority, int from)`
`(package private) void`	`removeFirstUsePos()`
`(package private) void`	`rewindRange()`
`(package private) void`	`setInsertMoveWhenActivated(boolean b)`
`void`	`setKind(LIRKind kind)`
`void`	`setLocationHint(Interval interval)`
`void`	`setSpillDefinitionPos(int pos)`
`(package private) void`	`setSpillSlot(StackSlotValue slot)`
`void`	`setSpillState(Interval.SpillState state)`
`int`	`spillDefinitionPos()`
`(package private) StackSlotValue`	`spillSlot()` Gets the canonical spill slot for this interval.
`Interval.SpillState`	`spillState()`
`(package private) Interval`	`split(int splitPos, LinearScan allocator)` Splits this interval at a specified position and returns the remainder as a new child interval of this interval's parent interval.
`(package private) boolean`	`splitChildCovers(int opId, LIRInstruction.OperandMode mode)`
`(package private) Interval`	`splitFromStart(int splitPos, LinearScan allocator)` Splits this interval at a specified position and returns the head as a new interval (this interval is the tail).
`Interval`	`splitParent()` Gets the split parent for this interval.
`(package private) int`	`to()`
`String`	`toString()`
`Interval.UsePosList`	`usePosList()` Gets the use position information for this interval.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail
- operand
```
public final AllocatableValue operand
```
  The register or variable for this interval prior to register allocation.
- operandNumber
```
public final int operandNumber
```
  The operand number for this interval's operand.
- location
```
private AllocatableValue location
```
  The register or spill slot assigned to this interval. In case of a spilled interval which is re-materialized this is Value.ILLEGAL.
- spillSlot
```
private StackSlotValue spillSlot
```
  The stack slot to which all splits of this interval are spilled if necessary.
- kind
```
private LIRKind kind
```
  The kind of this interval.
- first
```
private Range first
```
  The head of the list of ranges describing this interval. This list is sorted by instruction ids.
- usePosList
```
private Interval.UsePosList usePosList
```
  List of (use-positions, register-priorities) pairs, sorted by use-positions.
- current
```
private Range current
```
  Iterator used to traverse the ranges of an interval.
- next
```
Interval next
```
  Link to next interval in a sorted list of intervals that ends with EndMarker.
- state
```
Interval.State state
```
  The linear-scan state of this interval.
- cachedTo
```
private int cachedTo
```
- splitParent
```
private Interval splitParent
```
  The interval from which this one is derived. If this is a split parent, it points to itself.
- splitChildren
```
private List<Interval> splitChildren
```
  List of all intervals that are split off from this interval. This is only used if this is a split parent.
- currentSplitChild
```
private Interval currentSplitChild
```
  Current split child that has been active or inactive last (always stored in split parents).
- insertMoveWhenActivated
```
private boolean insertMoveWhenActivated
```
  Specifies if move is inserted between currentSplitChild and this interval when interval gets active the first time.
- spillState
```
private Interval.SpillState spillState
```
  For spill move optimization.
- spillDefinitionPos
```
private int spillDefinitionPos
```
  Position where this interval is defined (if defined only once).
- locationHint
```
private Interval locationHint
```
  This interval should be assigned the same location as the hint interval.
- materializedValue
```
private JavaConstant materializedValue
```
  The value with which a spilled child interval can be re-materialized. Currently this must be a Constant.
- numMaterializationValuesAdded
```
private int numMaterializationValuesAdded
```
  The number of times addMaterializationValue(JavaConstant) is called.
- EndMarker
```
static final Interval EndMarker
```
  Sentinel interval to denote the end of an interval list.

Constructor Detail

Interval

Interval(AllocatableValue operand,
         int operandNumber)

Method Detail

assignLocation

void assignLocation(AllocatableValue newLocation)

location
```
public AllocatableValue location()
```
Gets the register or spill slot assigned to this interval.

kind
```
public LIRKind kind()
```

setKind
```
public void setKind(LIRKind kind)
```

first
```
public Range first()
```

from
```
public int from()
```

to
```
int to()
```

numUsePositions
```
int numUsePositions()
```

setLocationHint

public void setLocationHint(Interval interval)

isSplitParent
```
public boolean isSplitParent()
```

isSplitChild
```
boolean isSplitChild()
```

splitParent
```
public Interval splitParent()
```
Gets the split parent for this interval.

spillSlot
```
StackSlotValue spillSlot()
```
Gets the canonical spill slot for this interval.

setSpillSlot

void setSpillSlot(StackSlotValue slot)

currentSplitChild
```
Interval currentSplitChild()
```

makeCurrentSplitChild
```
void makeCurrentSplitChild()
```

insertMoveWhenActivated
```
boolean insertMoveWhenActivated()
```

setInsertMoveWhenActivated

void setInsertMoveWhenActivated(boolean b)

spillState

public Interval.SpillState spillState()

spillDefinitionPos
```
public int spillDefinitionPos()
```

setSpillState

public void setSpillState(Interval.SpillState state)

setSpillDefinitionPos

public void setSpillDefinitionPos(int pos)

alwaysInMemory
```
public boolean alwaysInMemory()
```

removeFirstUsePos
```
void removeFirstUsePos()
```

intersects
```
boolean intersects(Interval i)
```

intersectsAt
```
int intersectsAt(Interval i)
```

rewindRange
```
void rewindRange()
```

nextRange
```
void nextRange()
```

currentFrom
```
int currentFrom()
```

currentTo
```
int currentTo()
```

currentAtEnd
```
boolean currentAtEnd()
```

currentIntersects

boolean currentIntersects(Interval it)

currentIntersectsAt
```
int currentIntersectsAt(Interval it)
```

addMaterializationValue
```
public void addMaterializationValue(JavaConstant value)
```
Sets the value which is used for re-materialization.

canMaterialize
```
public boolean canMaterialize()
```
Returns true if this interval can be re-materialized when spilled. This means that no spill-moves are needed. Instead of restore-moves the materializedValue is restored.

getMaterializedValue
```
public JavaConstant getMaterializedValue()
```
Returns a value which can be moved to a register instead of a restore-move from stack.

calcTo
```
int calcTo()
```

checkSplitChildren
```
boolean checkSplitChildren()
```

locationHint

public Interval locationHint(boolean searchSplitChild)

getSplitChildAtOpId

Interval getSplitChildAtOpId(int opId,
                             LIRInstruction.OperandMode mode,
                             LinearScan allocator)

checkSplitChild

private boolean checkSplitChild(Interval result,
                                int opId,
                                LinearScan allocator,
                                int toOffset,
                                LIRInstruction.OperandMode mode)

getIntervalCoveringOpId

Interval getIntervalCoveringOpId(int opId)

getSplitChildBeforeOpId

Interval getSplitChildBeforeOpId(int opId)

splitChildCovers

boolean splitChildCovers(int opId,
                         LIRInstruction.OperandMode mode)

adaptPriority

private Interval.RegisterPriority adaptPriority(Interval.RegisterPriority priority)

firstUsage

int firstUsage(Interval.RegisterPriority minRegisterPriority)

nextUsage

int nextUsage(Interval.RegisterPriority minRegisterPriority,
              int from)

nextUsageExact

int nextUsageExact(Interval.RegisterPriority exactRegisterPriority,
                   int from)

previousUsage

int previousUsage(Interval.RegisterPriority minRegisterPriority,
                  int from)

addUsePos

public void addUsePos(int pos,
                      Interval.RegisterPriority registerPriority)

addRange

public void addRange(int from,
                     int to)

newSplitChild

Interval newSplitChild(LinearScan allocator)

split
```
Interval split(int splitPos,
               LinearScan allocator)
```
Splits this interval at a specified position and returns the remainder as a new child interval of this interval's parent interval.
When an interval is split, a bi-directional link is established between the original parent interval and the children intervals that are split off this interval. When a split child is split again, the new created interval is a direct child of the original parent. That is, there is no tree of split children stored, just a flat list. All split children are spilled to the same spill slot.

Parameters:

splitPos - the position at which to split this interval

allocator - the register allocator context

Returns:

the child interval split off from this interval

splitFromStart
```
Interval splitFromStart(int splitPos,
                        LinearScan allocator)
```
Splits this interval at a specified position and returns the head as a new interval (this interval is the tail). Currently, only the first range can be split, and the new interval must not have split positions

covers

boolean covers(int opId,
               LIRInstruction.OperandMode mode)

hasHoleBetween

boolean hasHoleBetween(int holeFrom,
                       int holeTo)

toString
```
public String toString()
```
Overrides:

toString in class Object

usePosList
```
public Interval.UsePosList usePosList()
```
Gets the use position information for this interval.

logString
```
public String logString(LinearScan allocator)
```
Gets a single line string for logging the details of this interval to a log stream.

Parameters:

allocator - the register allocator context

getSplitChildren
```
List<Interval> getSplitChildren()
```

Class Interval

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

operand

operandNumber

location

spillSlot

kind

first

usePosList

current

next

state

cachedTo

splitParent

splitChildren

currentSplitChild

insertMoveWhenActivated

spillState

spillDefinitionPos

locationHint

materializedValue

numMaterializationValuesAdded

EndMarker

Constructor Detail

Interval

Method Detail

assignLocation

location

kind

setKind

first

from

to

numUsePositions

setLocationHint

isSplitParent

isSplitChild

splitParent

spillSlot

setSpillSlot

currentSplitChild

makeCurrentSplitChild

insertMoveWhenActivated

setInsertMoveWhenActivated

spillState

spillDefinitionPos

setSpillState

setSpillDefinitionPos

alwaysInMemory

removeFirstUsePos

intersects

intersectsAt

rewindRange

nextRange

currentFrom

currentTo

currentAtEnd

currentIntersects

currentIntersectsAt

addMaterializationValue

canMaterialize

getMaterializedValue

calcTo

checkSplitChildren

locationHint

getSplitChildAtOpId

checkSplitChild

getIntervalCoveringOpId

getSplitChildBeforeOpId

splitChildCovers

adaptPriority

firstUsage

nextUsage

nextUsageExact

previousUsage