GenericStackManager (Jikes RVM API)

java.lang.Object
- org.jikesrvm.compilers.opt.ir.IRTools
- - org.jikesrvm.compilers.opt.regalloc.GenericStackManager

Direct Known Subclasses:

StackManager
```
public abstract class GenericStackManager
extends IRTools
```
Class to manage the allocation of the "compiler-independent" portion of the stackframe.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`GenericStackManager.ScratchRegister` Class to represent a physical register currently allocated as a scratch register.

Field Summary

Fields
Modifier and Type	Field and Description
`private ActiveSet`	`activeSet` We may rely on information from linear scan to choose scratch registers.
`protected boolean`	`allocFrame`
`private int`	`caughtExceptionOffset` Memory location (4 bytes) to be used for caughtExceptions
`static byte`	`CONDITION_VALUE`
`private int`	`conversionOffset` Memory location (8 bytes) to be used for type conversions
`protected static boolean`	`DEBUG`
`static byte`	`DOUBLE_VALUE`
`static byte`	`FLOAT_VALUE`
`private boolean`	`frameRequired` Have we decided that a stack frame is required for this method?
`protected int`	`frameSize`
`static byte`	`INT_VALUE`
`protected IR`	`ir`
`protected int[]`	`nonVolatileFPRLocation`
`protected int[]`	`nonVolatileGPRLocation` An array which holds the spill location number used to stash nonvolatile registers.
`protected GenericRegisterPreferences`	`pref` Object holding register preferences
`private boolean`	`prologueYieldpoint` Is there a prologue yieldpoint in this method?
`protected RegisterAllocatorState`	`regAllocState`
`protected GenericRegisterRestrictions`	`restrict` Object holding register restrictions
`protected int[]`	`saveVolatileFPRLocation`
`protected int[]`	`saveVolatileGPRLocation` An array which holds the spill location number used to stash volatile registers in the SaveVolatile protocol.
`protected ArrayList<GenericStackManager.ScratchRegister>`	`scratchInUse` For each physical register, holds a ScratchRegister which records the current scratch assignment for the physical register.
`protected ScratchMap`	`scratchMap` An object used to track adjustments to the GC maps induced by scratch registers
`protected int`	`spillPointer` Spill pointer (in bytes) relative to the beginning of the stack frame (starts after the header).
`private int`	`sysCallOffset` We will have to save and restore all non-volatile registers around system calls, to protect ourselve from malicious native code that may bash these registers.
`private static boolean`	`USE_LINEAR_SCAN` Should we use information from linear scan in choosing scratch registers?
`protected static boolean`	`VERBOSE`
`protected static boolean`	`VERBOSE_DEBUG`
`protected static int`	`WORDSIZE` Size of a word, in bytes

Constructor Summary

Constructors
Constructor and Description

GenericStackManager()

Constructors
Constructor and Description
`GenericStackManager()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected static int`	`align(int number, int alignment)`
`abstract int`	`allocateNewSpillLocation(int type)` Allocates a new spill location and grows the frame size to reflect the new layout.
`Register`	`allocateNonVolatileRegister(Register symbReg)` Find a nonvolatile register to allocate starting at the reg corresponding to the symbolic register passed.
`int`	`allocateOnStackFrame(int size)` Allocates the specified number of bytes in the stackframe, returning the offset to the start of the allocated space.
`void`	`allocateParameterSpace(int s)` Ensure that there's enough space for passing parameters.
`int`	`allocateSpaceForCaughtException()` We encountered a catch block that actually uses its caught exception object; allocate a stack slot for the exception delivery code to use to pass the exception object to us.
`int`	`allocateSpaceForConversion()` We encountered a float/int conversion that uses the stack as temporary storage.
`int`	`allocateSpaceForSysCall(int n)` We will have to save and restore all non-volatile registers around system calls, to protect ourselves from malicious native code that may bash these registers.
`Register`	`allocateVolatileRegister(Register symbReg)` Find an volatile register to allocate starting at the reg corresponding to the symbolic register passed
`private boolean`	`appearsIn(Register r, Instruction s)`
`abstract void`	`cleanUpAndInsertEpilogue()` Cleans up some junk that's left in the IR after register allocation, and adds epilogue code.
`abstract void`	`computeNonVolatileArea()` Computes the number of stack words needed to hold nonvolatile registers.
`void`	`computeRestrictions(IR ir)` Sets up register restrictions.
`private GenericStackManager.ScratchRegister`	`createScratchBefore(RegisterAllocatorState regAllocState, Instruction s, Register r, Register symb)` Make physicals register r available to be used as a scratch register before instruction s.
`private boolean`	`definesSpillLocation(int loc, Instruction s)`
`private boolean`	`definesSpillLocation(Register r, Instruction s)`
`void`	`forceFrameAllocation()` We encountered a magic (get/set framepointer) that is going to force us to actually create the stack frame.
`protected boolean`	`frameIsRequired()`
`private GenericStackManager.ScratchRegister`	`getCurrentScratchRegister(Register r, Instruction s)` If there is a scratch register available which currently holds the value of symbolic register r, then return that scratch register.
`private GenericStackManager.ScratchRegister`	`getFirstAvailableScratchRegister(Register r, Instruction s)` Finds the first available register which can serve as a scratch register for symbolic register r in instruction s.
`private Register`	`getFirstDeadFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Return a FPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
`private Register`	`getFirstDeadGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Return a GPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r.
`private Register`	`getFirstFPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Returns a FPR that does not appear in instruction s, to be used as a scratch register to hold register r.
`private Register`	`getFirstGPRNotUsedIn(Register r, Instruction s, ArrayList<Register> reserved)` Return a GPR that does not appear in instruction s, to hold symbolic register r.
`abstract int`	`getFrameFixedSize()` Returns the size of the fixed portion of the stack.
`protected int`	`getNonvolatileFPROffset(int n)`
`protected int`	`getNonvolatileGPROffset(int n)`
`int`	`getOffsetForSysCall()` We will have to save and restore all non-volatile registers around system calls, to protect ourselves from malicious native code that may bash these registers.
`private GenericStackManager.ScratchRegister`	`getPhysicalScratchRegister(Register r)`
`(package private) GenericRegisterPreferences`	`getPreferences()`
`private ArrayList<Register>`	`getReservedScratchRegisters(Instruction s)`
`(package private) GenericRegisterRestrictions`	`getRestrictions()`
`(package private) ScratchMap`	`getScratchMap()`
`private GenericStackManager.ScratchRegister`	`getScratchRegister(Register symb, Instruction s, boolean beCheap)` Gets a scratch register to hold symbolic register symb in instruction s.
`private GenericStackManager.ScratchRegister`	`getScratchRegisterUsingIntervals(Register r, Instruction s)` Finds a register which can serve as a scratch register for symbolic register r in instruction s.
`byte`	`getValueType(Register r)` Given a symbolic register, return a code that indicates the type of the value stored in the register.
`protected boolean`	`hasPrologueYieldpoint()`
`private GenericStackManager.ScratchRegister`	`holdInScratchAfter(Instruction s, Register symb, boolean beCheap)` Inserts code as needed so that after instruction s, the value of a symbolic register will be held in a particular scratch physical register.
`abstract void`	`initForArch(IR ir)` Perform some architecture-specific initialization.
`abstract void`	`insertNormalPrologue()` Inserts the prologue for a normal method.
`private void`	`insertPrologue()`
`void`	`insertPrologueAndEpilogue()` PROLOGUE/EPILOGUE.
`void`	`insertSpillAfter(Instruction s, Register r, byte type, int location)` Insert a spill of a physical register after instruction s.
`abstract void`	`insertSpillBefore(Instruction s, Register r, byte type, int location)` Insert a spill of a physical register before instruction s.
`void`	`insertSpillCode()` After register allocation, go back through the IR and insert compensating code to deal with spills.
`void`	`insertSpillCode(ActiveSet set)` After register allocation, go back through the IR and insert compensating code to deal with spills.
`void`	`insertUnspillAfter(Instruction s, Register r, byte type, int location)` Insert a load of a physical register from a spill location before instruction s.
`abstract void`	`insertUnspillBefore(Instruction s, Register r, byte type, int location)` Insert a load of a physical register from a spill location before instruction s.
`boolean`	`isDeadBefore(Register r, Instruction s)`
`protected boolean`	`isLegal(Register symb, Register phys, Instruction s)`
`private boolean`	`isPEIWithCatch(Instruction s, BasicBlock instructionsBB)`
`abstract boolean`	`isSysCall(Instruction s)`
`private void`	`markDirtyScratchRegisters(Instruction s)` Walk over the currently available scratch registers.
`private GenericStackManager.ScratchRegister`	`moveToScratchBefore(Instruction s, Register symb, boolean beCheap)` Assigns symbolic register symb to a physical register, and inserts code before instruction s to load the register from the appropriate stack location.
`abstract boolean`	`needScratch(Register r, Instruction s)` Given symbolic register r in instruction s, do we need to ensure that r is in a scratch register is s (as opposed to a memory operand)
`void`	`prepare(IR ir)` Called as part of the register allocator startup.
`protected void`	`reloadScratchRegisterBefore(Instruction s, GenericStackManager.ScratchRegister scratch)` Restores the contents of a scratch register before instruction s if necessary.
`abstract void`	`replaceOperandWithSpillLocation(Instruction s, RegisterOperand symb)` In instruction s, replace all appearances of a symbolic register operand with uses of the appropriate spill location, as cached by the register allocator.
`private void`	`replaceRegisterWithScratch(Instruction s, Register r1, Register r2)` Replaces all occurrences of register r1 in an instruction with register r2.
`private void`	`restoreAllScratchRegistersBefore(Instruction s)` Walk over the currently available scratch registers, and spill their contents to memory before instruction s.
`abstract void`	`restoreScratchRegistersBefore(Instruction s)` Walk over the currently available scratch registers.
`protected void`	`setFrameRequired()` Records that we need a stack frame for this method.
`private Register`	`spillLocationUse(int loc, Instruction s)` Assuming instruction s uses the spill location loc, return the symbolic register that embodies that use.
`private Register`	`spillLocationUse(Register r, Instruction s)`
`protected void`	`unloadScratchRegisterBefore(Instruction s, GenericStackManager.ScratchRegister scratch)` Spills the contents of a scratch register to memory before instruction s.
`private boolean`	`usesSpillLocation(int loc, Instruction s)`
`private boolean`	`usesSpillLocation(Register r, Instruction s)`

Methods inherited from class org.jikesrvm.compilers.opt.ir.IRTools
A, AC, AC, CPOS, CR, D, DC, defDoublesAsUse, definedIn, F, FC, getCondMoveOp, getDefaultOperand, getLoadOp, getLoadOp, getMoveOp, getStoreOp, getStoreOp, I, IC, insertInstructionsAfter, L, LC, makeBlockOnEdge, mayBeVolatileFieldLoad, moveInstruction, moveIntoRegister, moveIntoRegister, nonPEIGC, offsetOperand, TG, usedIn, useDoublesAsDef

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

- Field Detail
  - INT_VALUE
```
public static final byte INT_VALUE
```
    See Also:
    
    Constant Field Values
  - DOUBLE_VALUE
```
public static final byte DOUBLE_VALUE
```
    See Also:
    
    Constant Field Values
  - FLOAT_VALUE
```
public static final byte FLOAT_VALUE
```
    See Also:
    
    Constant Field Values
  - CONDITION_VALUE
```
public static final byte CONDITION_VALUE
```
    See Also:
    
    Constant Field Values
  - DEBUG
```
protected static final boolean DEBUG
```
    See Also:
    
    Constant Field Values
  - VERBOSE
```
protected static final boolean VERBOSE
```
    See Also:
    
    Constant Field Values
  - VERBOSE_DEBUG
```
protected static final boolean VERBOSE_DEBUG
```
    See Also:
    
    Constant Field Values
  - WORDSIZE
```
protected static final int WORDSIZE
```
    Size of a word, in bytes
    
    See Also:
    
    Constant Field Values
  - ir
```
protected IR ir
```
  - regAllocState
```
protected RegisterAllocatorState regAllocState
```
  - frameSize
```
protected int frameSize
```
  - allocFrame
```
protected boolean allocFrame
```
  - pref
```
protected final GenericRegisterPreferences pref
```
    Object holding register preferences
  - restrict
```
protected GenericRegisterRestrictions restrict
```
    Object holding register restrictions
  - spillPointer
```
protected int spillPointer
```
    Spill pointer (in bytes) relative to the beginning of the stack frame (starts after the header).
  - frameRequired
```
private boolean frameRequired
```
    Have we decided that a stack frame is required for this method?
  - conversionOffset
```
private int conversionOffset
```
    Memory location (8 bytes) to be used for type conversions
  - caughtExceptionOffset
```
private int caughtExceptionOffset
```
    Memory location (4 bytes) to be used for caughtExceptions
  - prologueYieldpoint
```
private boolean prologueYieldpoint
```
    Is there a prologue yieldpoint in this method?
  - sysCallOffset
```
private int sysCallOffset
```
    We will have to save and restore all non-volatile registers around system calls, to protect ourselve from malicious native code that may bash these registers. This field, when non-zero, holds the stack-frame offset reserved to hold this data.
  - scratchInUse
```
protected final ArrayList<GenericStackManager.ScratchRegister> scratchInUse
```
    For each physical register, holds a ScratchRegister which records the current scratch assignment for the physical register.
  - nonVolatileGPRLocation
```
protected final int[] nonVolatileGPRLocation
```
    An array which holds the spill location number used to stash nonvolatile registers.
  - nonVolatileFPRLocation
```
protected final int[] nonVolatileFPRLocation
```
  - saveVolatileGPRLocation
```
protected final int[] saveVolatileGPRLocation
```
    An array which holds the spill location number used to stash volatile registers in the SaveVolatile protocol.
  - saveVolatileFPRLocation
```
protected final int[] saveVolatileFPRLocation
```
  - scratchMap
```
protected ScratchMap scratchMap
```
    An object used to track adjustments to the GC maps induced by scratch registers
  - USE_LINEAR_SCAN
```
private static boolean USE_LINEAR_SCAN
```
    Should we use information from linear scan in choosing scratch registers?
  - activeSet
```
private ActiveSet activeSet
```
    We may rely on information from linear scan to choose scratch registers. If so, the following holds a pointer to some information from linear scan analysis.
- Constructor Detail
  - GenericStackManager
```
public GenericStackManager()
```
- Method Detail
  - getPreferences
```
GenericRegisterPreferences getPreferences()
```
  - getRestrictions
```
GenericRegisterRestrictions getRestrictions()
```
  - getScratchMap
```
ScratchMap getScratchMap()
```
  - initForArch
```
public abstract void initForArch(IR ir)
```
    Perform some architecture-specific initialization.
    
    Parameters:
    
    ir - the IR
  - isSysCall
```
public abstract boolean isSysCall(Instruction s)
```
    Parameters:
    
    s - the instruction to check
    
    Returns:
    
    whether the instruction is a system call?
  - needScratch
```
public abstract boolean needScratch(Register r,
                                    Instruction s)
```
    Given symbolic register r in instruction s, do we need to ensure that r is in a scratch register is s (as opposed to a memory operand)
    
    Parameters:
    
    r - the symbolic register
    
    s - the instruction that has an occurrence of the register
    
    Returns:
    
    true if the symbolic register needs to be a scratch register
  - allocateNewSpillLocation
```
public abstract int allocateNewSpillLocation(int type)
```
    Allocates a new spill location and grows the frame size to reflect the new layout.
    
    Parameters:
    
    type - the type to spill
    
    Returns:
    
    the spill location
  - cleanUpAndInsertEpilogue
```
public abstract void cleanUpAndInsertEpilogue()
```
    Cleans up some junk that's left in the IR after register allocation, and adds epilogue code.
  - getFrameFixedSize
```
public abstract int getFrameFixedSize()
```
    Returns the size of the fixed portion of the stack. (in other words, the difference between the framepointer and the stackpointer after the prologue of the method completes).
    
    Returns:
    
    size in bytes of the fixed portion of the stackframe
  - computeNonVolatileArea
```
public abstract void computeNonVolatileArea()
```
    Computes the number of stack words needed to hold nonvolatile registers. Side effects:
    - updates the OptCompiler structure
    - updates the frameSize field of this object
    - updates the frameRequired field of this object
  - insertNormalPrologue
```
public abstract void insertNormalPrologue()
```
    Inserts the prologue for a normal method.
  - restoreScratchRegistersBefore
```
public abstract void restoreScratchRegistersBefore(Instruction s)
```
    Walk over the currently available scratch registers.
    For any scratch register r which is def'ed by instruction s, spill r before s and remove r from the pool of available scratch registers.
    For any scratch register r which is used by instruction s, restore r before s and remove r from the pool of available scratch registers.
    For any scratch register r which has current contents symb, and symb is spilled to location M, and s defs M: the old value of symb is dead. Mark this.
    Invalidate any scratch register assignments that are illegal in s.
    
    Parameters:
    
    s - the instruction to process
  - replaceOperandWithSpillLocation
```
public abstract void replaceOperandWithSpillLocation(Instruction s,
                                                     RegisterOperand symb)
```
    In instruction s, replace all appearances of a symbolic register operand with uses of the appropriate spill location, as cached by the register allocator.
    
    Parameters:
    
    s - the instruction to mutate.
    
    symb - the symbolic register operand to replace
  - replaceRegisterWithScratch
```
private void replaceRegisterWithScratch(Instruction s,
                                        Register r1,
                                        Register r2)
```
    Replaces all occurrences of register r1 in an instruction with register r2. Also, for any register r3 that is spilled to the same location as r1, replace r3 with r2.
    
    Parameters:
    
    s - instruction to process
    
    r1 - register to replace
    
    r2 - the replacement register
  - allocateSpaceForSysCall
```
public int allocateSpaceForSysCall(int n)
```
    We will have to save and restore all non-volatile registers around system calls, to protect ourselves from malicious native code that may bash these registers. Call this routine before register allocation in order to allocate space on the stack frame to store these registers.
    
    Parameters:
    
    n - the number of GPR registers to save and restore.
    
    Returns:
    
    the offset into the stack where n*4 contiguous words are reserved
  - getOffsetForSysCall
```
public int getOffsetForSysCall()
```
    We will have to save and restore all non-volatile registers around system calls, to protect ourselves from malicious native code that may bash these registers. Call this routine before register allocation in order to get the stack-frame offset previously reserved for this data.
    
    Returns:
    
    the offset into the stack where n*4 contiguous words are reserved
  - unloadScratchRegisterBefore
```
protected void unloadScratchRegisterBefore(Instruction s,
                                           GenericStackManager.ScratchRegister scratch)
```
    Spills the contents of a scratch register to memory before instruction s.
    
    Parameters:
    
    scratch - the scratch register to spill
    
    s - the instruction before which the spill needs to occur
  - reloadScratchRegisterBefore
```
protected void reloadScratchRegisterBefore(Instruction s,
                                           GenericStackManager.ScratchRegister scratch)
```
    Restores the contents of a scratch register before instruction s if necessary.
    
    Parameters:
    
    scratch - the scratch register whose contents may need to be restored
    
    s - the instruction before which the restores needs to occur
  - getReservedScratchRegisters
```
private ArrayList<Register> getReservedScratchRegisters(Instruction s)
```
    Parameters:
    
    s - the instruction whose reserved scratch registers are of interest
    
    Returns:
    
    the scratch registers which are currently reserved for use in the instruction (may be an empty list but will never be null)
  - getCurrentScratchRegister
```
private GenericStackManager.ScratchRegister getCurrentScratchRegister(Register r,
                                                                      Instruction s)
```
    If there is a scratch register available which currently holds the value of symbolic register r, then return that scratch register.
    Additionally, if there is a scratch register available which is mapped to the same stack location as r, then return that scratch register.
    Else return null.
    
    Parameters:
    
    r - the symbolic register to hold
    
    s - the instruction for which we need r in a register
    
    Returns:
    
    a register as described above or null
  - getPhysicalScratchRegister
```
private GenericStackManager.ScratchRegister getPhysicalScratchRegister(Register r)
```
    Parameters:
    
    r - the register to check
    
    Returns:
    
    the scratch register for r if it's currently in use as a scratch register, null otherwise
  - markDirtyScratchRegisters
```
private void markDirtyScratchRegisters(Instruction s)
```
    Walk over the currently available scratch registers.
    For any register which is dirty, note this in the scratch map for instruction s.
    
    Parameters:
    
    s - the instruction which needs an update in the scratch map
  - restoreAllScratchRegistersBefore
```
private void restoreAllScratchRegistersBefore(Instruction s)
```
    Walk over the currently available scratch registers, and spill their contents to memory before instruction s. Also restore the correct live value for each scratch register. Normally, s should end a basic block.
    SPECIAL CASE: If s is a return instruction, only restore the scratch registers that are used by s. The others are dead.
    
    Parameters:
    
    s - the instruction before which the scratch registers need to be restored
  - isDeadBefore
```
public boolean isDeadBefore(Register r,
                            Instruction s)
```
    Parameters:
    
    r - the register
    
    s - the instruction
    
    Returns:
    
    true if the register is dead immediately before the instruction
  - holdInScratchAfter
```
private GenericStackManager.ScratchRegister holdInScratchAfter(Instruction s,
                                                               Register symb,
                                                               boolean beCheap)
```
    Inserts code as needed so that after instruction s, the value of a symbolic register will be held in a particular scratch physical register.
    
    Parameters:
    
    s - the instruction after which the value will be held in scratch
    
    symb - the register whose value needs to be held in scratch
    
    beCheap - don't expend much effort optimizing scratch assignments
    
    Returns:
    
    the physical scratch register that holds the value after instruction s
  - isLegal
```
protected boolean isLegal(Register symb,
                          Register phys,
                          Instruction s)
```
    Parameters:
    
    symb - the symbolic register that we want to assign
    
    phys - the scratch register
    
    s - the instruction where the assignment would take place
    
    Returns:
    
    whether it's legal to assign the symbolic register to the scratch register in the given instruction
  - getScratchRegister
```
private GenericStackManager.ScratchRegister getScratchRegister(Register symb,
                                                               Instruction s,
                                                               boolean beCheap)
```
    Gets a scratch register to hold symbolic register symb in instruction s.
    
    Parameters:
    
    symb - the symbolic register to hold
    
    s - the instruction where the scratch register is needed
    
    beCheap - don't expend too much effort
    
    Returns:
    
    a scratch register, never null
  - getScratchRegisterUsingIntervals
```
private GenericStackManager.ScratchRegister getScratchRegisterUsingIntervals(Register r,
                                                                             Instruction s)
```
    Finds a register which can serve as a scratch register for symbolic register r in instruction s.
    Inserts spills if necessary to ensure that the returned scratch register is free for use.
    
    Parameters:
    
    r - the symbolic register that needs a scratch
    
    s - the instruction where the scratch register is needed
    
    Returns:
    
    a scratch register, never null
  - getFirstAvailableScratchRegister
```
private GenericStackManager.ScratchRegister getFirstAvailableScratchRegister(Register r,
                                                                             Instruction s)
```
    Finds the first available register which can serve as a scratch register for symbolic register r in instruction s.
    Inserts spills if necessary to ensure that the returned scratch register is free for use.
    
    Parameters:
    
    r - the symbolic register that needs a scratch
    
    s - the instruction where the scratch register is needed
    
    Returns:
    
    a scratch register, never null
  - moveToScratchBefore
```
private GenericStackManager.ScratchRegister moveToScratchBefore(Instruction s,
                                                                Register symb,
                                                                boolean beCheap)
```
    Assigns symbolic register symb to a physical register, and inserts code before instruction s to load the register from the appropriate stack location.
    
    Parameters:
    
    s - the instruction before which the register needs to be loaded
    
    symb - the symbolic register to be assigned to a scratch
    
    beCheap - don't expend to much effort to optimize scratch assignments
    
    Returns:
    
    the physical register used to hold the value when it is loaded from the spill location
  - createScratchBefore
```
private GenericStackManager.ScratchRegister createScratchBefore(RegisterAllocatorState regAllocState,
                                                                Instruction s,
                                                                Register r,
                                                                Register symb)
```
    Make physicals register r available to be used as a scratch register before instruction s. In instruction s, r will hold the value of register symb.
    
    Parameters:
    
    regAllocState - TODO
    
    s - the instruction before which the scratch register will be created
    
    r - the physical register to be used as scratch
    
    symb - the symbolic register which needs a scratch register
    
    Returns:
    
    the scratch register that will hold the value
  - usesSpillLocation
```
private boolean usesSpillLocation(Register r,
                                  Instruction s)
```
  - spillLocationUse
```
private Register spillLocationUse(Register r,
                                  Instruction s)
```
  - definesSpillLocation
```
private boolean definesSpillLocation(Register r,
                                     Instruction s)
```
  - definesSpillLocation
```
private boolean definesSpillLocation(int loc,
                                     Instruction s)
```
  - usesSpillLocation
```
private boolean usesSpillLocation(int loc,
                                  Instruction s)
```
  - spillLocationUse
```
private Register spillLocationUse(int loc,
                                  Instruction s)
```
    Assuming instruction s uses the spill location loc, return the symbolic register that embodies that use.
    Note that at most one such register can be used, since at most one live register can use a given spill location.
    
    Parameters:
    
    s - instruction to check
    
    loc - spill location
    
    Returns:
    
    the symbolic register that belongs to the spill location
  - getFirstFPRNotUsedIn
```
private Register getFirstFPRNotUsedIn(Register r,
                                      Instruction s,
                                      ArrayList<Register> reserved)
```
    Returns a FPR that does not appear in instruction s, to be used as a scratch register to hold register r. Except, does NOT return any register that is a member of the reserved set.
    
    Parameters:
    
    r - the register that needs a scratch register
    
    s - the instruction for which the scratch register is needed
    
    reserved - the registers that must not be used
    
    Returns:
    
    a free FPR
    
    Throws:
    
    OptimizingCompilerException - if no free FPR was found
  - getFirstDeadFPRNotUsedIn
```
private Register getFirstDeadFPRNotUsedIn(Register r,
                                          Instruction s,
                                          ArrayList<Register> reserved)
```
    Return a FPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r. Except, do NOT return any register that is a member of the reserved set.
    
    Parameters:
    
    r - the register that needs a scratch register
    
    s - the instruction for which the scratch register is needed
    
    reserved - the registers that must not be used
    
    Returns:
    
    null if no register found, a dead and unused FPR otherwise
  - getFirstGPRNotUsedIn
```
private Register getFirstGPRNotUsedIn(Register r,
                                      Instruction s,
                                      ArrayList<Register> reserved)
```
    Return a GPR that does not appear in instruction s, to hold symbolic register r. Except, do NOT return any register that is a member of the reserved set.
    
    Parameters:
    
    r - the register that needs a scratch register
    
    s - the instruction for which the scratch register is needed
    
    reserved - the registers that must not be used
    
    Returns:
    
    a free GPR
  - getFirstDeadGPRNotUsedIn
```
private Register getFirstDeadGPRNotUsedIn(Register r,
                                          Instruction s,
                                          ArrayList<Register> reserved)
```
    Return a GPR that does not appear in instruction s, and is dead before instruction s, to hold symbolic register r. Except, do NOT return any register that is a member of the reserved set.
    
    Parameters:
    
    r - the register that needs a scratch register
    
    s - the instruction for which the scratch register is needed
    
    reserved - the registers that must not be used
    
    Returns:
    
    null if no register found, a dead and unused GPR otherwise
  - appearsIn
```
private boolean appearsIn(Register r,
                          Instruction s)
```
  - isPEIWithCatch
```
private boolean isPEIWithCatch(Instruction s,
                               BasicBlock instructionsBB)
```
    Parameters:
    
    s - the instruction to check
    
    instructionsBB - the block that contains the instruction
    
    Returns:
    
    whether the instruction is s a PEI (potentially excepting instruction, i.e. it can throw an exception) with a reachable catch block
  - getNonvolatileGPROffset
```
protected int getNonvolatileGPROffset(int n)
```
    Parameters:
    
    n - number of the non-volatile GPR
    
    Returns:
    
    the offset from the frame pointer for the place to store the nth nonvolatile GPR.
  - getNonvolatileFPROffset
```
protected int getNonvolatileFPROffset(int n)
```
    Parameters:
    
    n - number of the non-volatile FPR
    
    Returns:
    
    the offset from the frame pointer for the place to store the nth nonvolatile FPR.
  - insertPrologueAndEpilogue
```
public final void insertPrologueAndEpilogue()
```
    PROLOGUE/EPILOGUE. Note: This must be done after register allocation!
  - insertPrologue
```
private void insertPrologue()
```
  - insertSpillCode
```
public void insertSpillCode()
```
    After register allocation, go back through the IR and insert compensating code to deal with spills.
  - insertSpillCode
```
public void insertSpillCode(ActiveSet set)
```
    After register allocation, go back through the IR and insert compensating code to deal with spills.
    
    Parameters:
    
    set - information from linear scan analysis (may be null)
  - insertSpillBefore
```
public abstract void insertSpillBefore(Instruction s,
                                       Register r,
                                       byte type,
                                       int location)
```
    Insert a spill of a physical register before instruction s.
    
    Parameters:
    
    s - the instruction before which the spill should occur
    
    r - the register (should be physical) to spill
    
    type - one of INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, or CONDITION_VALUE
    
    location - the spill location
  - insertSpillAfter
```
public final void insertSpillAfter(Instruction s,
                                   Register r,
                                   byte type,
                                   int location)
```
    Insert a spill of a physical register after instruction s.
    
    Parameters:
    
    s - the instruction after which the spill should occur
    
    r - the register (should be physical) to spill
    
    type - one of INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, or CONDITION_VALUE
    
    location - the spill location
  - insertUnspillBefore
```
public abstract void insertUnspillBefore(Instruction s,
                                         Register r,
                                         byte type,
                                         int location)
```
    Insert a load of a physical register from a spill location before instruction s.
    
    Parameters:
    
    s - the instruction before which the spill should occur
    
    r - the register (should be physical) to spill
    
    type - one of INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, or CONDITION_VALUE
    
    location - the spill location
  - insertUnspillAfter
```
public final void insertUnspillAfter(Instruction s,
                                     Register r,
                                     byte type,
                                     int location)
```
    Insert a load of a physical register from a spill location before instruction s.
    
    Parameters:
    
    s - the instruction before which the spill should occur
    
    r - the register (should be physical) to spill
    
    type - one of INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, or CONDITION_VALUE
    
    location - the spill location
  - frameIsRequired
```
protected boolean frameIsRequired()
```
    Returns:
    
    true if and only if a stack frame must be allocated for this method l
  - setFrameRequired
```
protected void setFrameRequired()
```
    Records that we need a stack frame for this method.
  - hasPrologueYieldpoint
```
protected boolean hasPrologueYieldpoint()
```
    Returns:
    
    true if and only if this IR has a prologue yieldpoint
  - allocateParameterSpace
```
public void allocateParameterSpace(int s)
```
    Ensure that there's enough space for passing parameters. We need size - STACKFRAME_HEADER_SIZE bytes.
    
    Parameters:
    
    s - space needed for parameters
  - allocateOnStackFrame
```
public int allocateOnStackFrame(int size)
```
    Allocates the specified number of bytes in the stackframe, returning the offset to the start of the allocated space.
    
    Parameters:
    
    size - the number of bytes to allocate
    
    Returns:
    
    offset to the start of the allocated space.
  - forceFrameAllocation
```
public void forceFrameAllocation()
```
    We encountered a magic (get/set framepointer) that is going to force us to actually create the stack frame.
  - allocateSpaceForConversion
```
public int allocateSpaceForConversion()
```
    We encountered a float/int conversion that uses the stack as temporary storage.
    
    Returns:
    
    offset to the start of the allocated space
  - allocateSpaceForCaughtException
```
public int allocateSpaceForCaughtException()
```
    We encountered a catch block that actually uses its caught exception object; allocate a stack slot for the exception delivery code to use to pass the exception object to us.
    
    Returns:
    
    offset to the start of the allocated space
  - prepare
```
public void prepare(IR ir)
```
    Called as part of the register allocator startup.
    1. examine the IR to determine whether or not we need to allocate a stack frame
    2. given that decison, determine whether or not we need to have prologue/epilogue yieldpoints. If we don't need them, remove them. Set up register preferences.
    3. initialization code for the old RegisterManager
    4. save caughtExceptionOffset where the exception deliverer can find it
    5. initialize the restrictions object
    Parameters:
    
    ir - the IR
  - computeRestrictions
```
public final void computeRestrictions(IR ir)
```
    Sets up register restrictions.
    
    Parameters:
    
    ir - the IR which will get the restrictions
  - allocateVolatileRegister
```
public final Register allocateVolatileRegister(Register symbReg)
```
    Find an volatile register to allocate starting at the reg corresponding to the symbolic register passed
    
    Parameters:
    
    symbReg - the place to start the search
    
    Returns:
    
    the allocated register or null
  - getValueType
```
public final byte getValueType(Register r)
```
    Given a symbolic register, return a code that indicates the type of the value stored in the register. Note: This routine returns INT_VALUE for longs
    
    Parameters:
    
    r - a symbolic register
    
    Returns:
    
    one of INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, CONDITION_VALUE
  - align
```
protected static int align(int number,
                           int alignment)
```
  - allocateNonVolatileRegister
```
public final Register allocateNonVolatileRegister(Register symbReg)
```
    Find a nonvolatile register to allocate starting at the reg corresponding to the symbolic register passed.
    TODO: Clean up this interface.
    
    Parameters:
    
    symbReg - the place to start the search
    
    Returns:
    
    the allocated register or null

Class GenericStackManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.jikesrvm.compilers.opt.ir.IRTools

Methods inherited from class java.lang.Object

Field Detail

INT_VALUE

DOUBLE_VALUE

FLOAT_VALUE

CONDITION_VALUE

DEBUG

VERBOSE

VERBOSE_DEBUG

WORDSIZE

ir

regAllocState

frameSize

allocFrame

pref

restrict

spillPointer

frameRequired

conversionOffset

caughtExceptionOffset

prologueYieldpoint

sysCallOffset

scratchInUse

nonVolatileGPRLocation

nonVolatileFPRLocation

saveVolatileGPRLocation

saveVolatileFPRLocation

scratchMap

USE_LINEAR_SCAN

activeSet

Constructor Detail

GenericStackManager

Method Detail

getPreferences

getRestrictions

getScratchMap

initForArch

isSysCall

needScratch

allocateNewSpillLocation

cleanUpAndInsertEpilogue

getFrameFixedSize

computeNonVolatileArea

insertNormalPrologue

restoreScratchRegistersBefore

replaceOperandWithSpillLocation

replaceRegisterWithScratch

allocateSpaceForSysCall

getOffsetForSysCall

unloadScratchRegisterBefore

reloadScratchRegisterBefore

getReservedScratchRegisters

getCurrentScratchRegister

getPhysicalScratchRegister

markDirtyScratchRegisters

restoreAllScratchRegistersBefore

isDeadBefore

holdInScratchAfter

isLegal

getScratchRegister

getScratchRegisterUsingIntervals

getFirstAvailableScratchRegister

moveToScratchBefore

createScratchBefore

usesSpillLocation

spillLocationUse

definesSpillLocation

definesSpillLocation

usesSpillLocation

spillLocationUse

getFirstFPRNotUsedIn

getFirstDeadFPRNotUsedIn

getFirstGPRNotUsedIn

getFirstDeadGPRNotUsedIn