@Test
public void assignCausesAssignmentOfTheIntervalsRegisterToTheGivenRegister() {
Register r = new Register(0);
CompoundInterval ci = new CompoundInterval(DEFAULT_BEGIN, DEFAULT_END, r);
Register s = new Register(1);
RegisterAllocatorState regAllocState = new RegisterAllocatorState(0);
assertThat(ci.isAssigned(regAllocState), is(false));
assertNull(ci.getAssignment(regAllocState));
ci.assign(s);
assertThat(s.mapsToRegister, is(r));
assertThat(!s.isSpilled() && s.isTouched() && s.isAllocated(), is(true));
assertThat(r.mapsToRegister, is(s));
assertThat(!r.isSpilled() && r.isTouched() && r.isAllocated(), is(true));
assertThat(ci.isAssigned(regAllocState), is(true));
assertThat(ci.getAssignment(regAllocState), is(s));
}
@Override
public void computeNonVolatileArea() {
GenericPhysicalRegisterSet phys = ir.regpool.getPhysicalRegisterSet();
if (ir.compiledMethod.isSaveVolatile()) {
// Record that we use every nonvolatile GPR
int numGprNv = PhysicalRegisterSet.getNumberOfNonvolatileGPRs();
ir.compiledMethod.setNumberOfNonvolatileGPRs((short) numGprNv);
// set the frame size
frameSize += numGprNv * WORDSIZE;
frameSize = align(frameSize, STACKFRAME_ALIGNMENT);
// TODO!!
ir.compiledMethod.setNumberOfNonvolatileFPRs((short) 0);
// Record that we need a stack frame.
setFrameRequired();
int fpuStateSaveAreaBegin = spillPointer;
// Calculate FPU state save area for restoreFloatingPointState(..)
// and saveFloatingPointState(..)
if (SSE2_FULL) {
for (int i = 0; i < 8; i++) {
fsaveLocation = allocateNewSpillLocation(DOUBLE_REG);
}
} else {
// Grab 108 bytes (same as 27 4-byte spills) in the stack
// frame, as a place to store the floating-point state with FSAVE
for (int i = 0; i < 27; i++) {
fsaveLocation = allocateNewSpillLocation(INT_REG);
}
}
int fpuStateSaveAreaEnd = spillPointer;
int fpuStateSize = fpuStateSaveAreaEnd - fpuStateSaveAreaBegin;
if (VM.VerifyAssertions) {
VM._assert(fpuStateSize == OPT_SAVE_VOLATILE_SPACE_FOR_FPU_STATE);
}
int volatileGPRSaveAreaBegin = spillPointer;
// Map each volatile register to a spill location.
int i = 0;
for (Enumeration<Register> e = phys.enumerateVolatileGPRs(); e.hasMoreElements(); i++) {
e.nextElement();
// Note that as a side effect, the following call bumps up the
// frame size.
saveVolatileGPRLocation[i] = allocateNewSpillLocation(INT_REG);
}
int volatileGPRSaveAreaEnd = spillPointer;
int volatileGPRSaveAreaSize = volatileGPRSaveAreaEnd - volatileGPRSaveAreaBegin;
if (VM.VerifyAssertions) {
VM._assert(volatileGPRSaveAreaSize == OPT_SAVE_VOLATILE_SPACE_FOR_VOLATILE_GPRS);
VM._assert((volatileGPRSaveAreaSize + fpuStateSize) == OPT_SAVE_VOLATILE_TOTAL_SIZE);
}
// Map each non-volatile register to a spill location.
i = 0;
for (Enumeration<Register> e = phys.enumerateNonvolatileGPRs(); e.hasMoreElements(); i++) {
e.nextElement();
// Note that as a side effect, the following call bumps up the
// frame size.
nonVolatileGPRLocation[i] = allocateNewSpillLocation(INT_REG);
}
// Set the offset to find non-volatiles.
int gprOffset = getNonvolatileGPROffset(0);
ir.compiledMethod.setUnsignedNonVolatileOffset(gprOffset);
} else {
// Count the number of nonvolatiles used.
int numGprNv = 0;
int i = 0;
for (Enumeration<Register> e = phys.enumerateNonvolatileGPRs(); e.hasMoreElements(); ) {
Register r = e.nextElement();
if (r.isTouched()) {
// Note that as a side effect, the following call bumps up the
// frame size.
nonVolatileGPRLocation[i++] = allocateNewSpillLocation(INT_REG);
numGprNv++;
}
}
// Update the OptCompiledMethod object.
ir.compiledMethod.setNumberOfNonvolatileGPRs((short) numGprNv);
if (numGprNv > 0) {
int gprOffset = getNonvolatileGPROffset(0);
ir.compiledMethod.setUnsignedNonVolatileOffset(gprOffset);
// record that we need a stack frame
setFrameRequired();
} else {
ir.compiledMethod.setUnsignedNonVolatileOffset(0);
}
ir.compiledMethod.setNumberOfNonvolatileFPRs((short) 0);
}
}
