/*
* Copyright (c) 2000, 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
package sun.jvm.hotspot.runtime.sparc;
import java.util.*;
import sun.jvm.hotspot.asm.sparc.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.runtime.*;
import sun.jvm.hotspot.types.*;
import sun.jvm.hotspot.utilities.*;
public class SPARCRegisterMap extends RegisterMap {
/** Register window save area (for L and I regs) */
private Address window;
/** Previous save area (for O regs, if needed) */
private Address youngerWindow;
private static int registerImplNumberOfRegisters;
// Unified register numbering scheme: each 32-bits counts as a register
// number, so all the V9 registers take 2 slots.
private static int[] R_L_nums = new int[] {0+040,2+040,4+040,6+040,8+040,10+040,12+040,14+040};
private static int[] R_I_nums = new int[] {0+060,2+060,4+060,6+060,8+060,10+060,12+060,14+060};
private static int[] R_O_nums = new int[] {0+020,2+020,4+020,6+020,8+020,10+020,12+020,14+020};
private static int[] R_G_nums = new int[] {0+000,2+000,4+000,6+000,8+000,10+000,12+000,14+000};
private static long badMask;
private static long R_LIO_mask;
private static int sizeofJint;
static {
VM.registerVMInitializedObserver(new Observer() {
public void update(Observable o, Object data) {
initialize(VM.getVM().getTypeDataBase());
}
});
}
private static void initialize(TypeDataBase db) {
badMask = 0;
R_LIO_mask = 0;
sizeofJint = (int) db.lookupType("jint").getSize();
registerImplNumberOfRegisters = db.lookupIntConstant("RegisterImpl::number_of_registers").intValue();
for (int i = 0; i < 8; i++) {
Assert.that(R_L_nums[i] < locationValidTypeSize, "in first chunk");
Assert.that(R_I_nums[i] < locationValidTypeSize, "in first chunk");
Assert.that(R_O_nums[i] < locationValidTypeSize, "in first chunk");
Assert.that(R_G_nums[i] < locationValidTypeSize, "in first chunk");
}
badMask |= ((long) 1 << R_O_nums[6]); // SP
badMask |= ((long) 1 << R_O_nums[7]); // cPC
badMask |= ((long) 1 << R_I_nums[6]); // FP
badMask |= ((long) 1 << R_I_nums[7]); // rPC
badMask |= ((long) 1 << R_G_nums[2]); // TLS
badMask |= ((long) 1 << R_G_nums[7]); // reserved by libthread
for (int i = 0; i < 8; i++) {
R_LIO_mask |= ((long) 1 << R_L_nums[i]);
R_LIO_mask |= ((long) 1 << R_I_nums[i]);
R_LIO_mask |= ((long) 1 << R_O_nums[i]);
}
}
/** This is the only public constructor, and is only called by
SolarisSPARCJavaThread */
public SPARCRegisterMap(JavaThread thread, boolean updateMap) {
super(thread, updateMap);
}
protected SPARCRegisterMap(RegisterMap map) {
super(map);
}
public Object clone() {
SPARCRegisterMap retval = new SPARCRegisterMap(this);
return retval;
}
protected void clearPD() {
if (thread.hasLastJavaFrame()) {
Frame fr = thread.getLastFrame();
window = fr.getSP();
} else {
window = null;
if (VM.getVM().isDebugging()) {
Frame fr = thread.getCurrentFrameGuess();
if (fr != null) {
window = fr.getSP();
}
}
}
youngerWindow = null;
}
protected Address getLocationPD(VMReg vmreg) {
VM vm = VM.getVM();
int regname = vmreg.getValue();
if (Assert.ASSERTS_ENABLED) {
Assert.that(0 <= regname && regname < regCount, "sanity check");
}
// Only the GPRs get handled this way
if (regname >= (registerImplNumberOfRegisters << 1)) {
return null;
}
// don't talk about bad registers
if ((badMask & ((long) 1 << regname)) != 0) {
return null;
}
// Convert to a GPR
int secondWord = 0;
// 32-bit registers for in, out and local
if (!isEven(regname)) {
if (vm.isLP64()) {
secondWord = sizeofJint;
} else {
return null;
}
}
SPARCRegister reg = new SPARCRegister(regname >> 1);
if (reg.isOut()) {
if (Assert.ASSERTS_ENABLED) {
Assert.that(youngerWindow != null, "Younger window should be available");
}
return youngerWindow.addOffsetTo(reg.afterSave().spOffsetInSavedWindow() + secondWord);
}
if (reg.isLocal() || reg.isIn()) {
if (Assert.ASSERTS_ENABLED) {
Assert.that(window != null, "Window should be available");
}
return window.addOffsetTo(reg.spOffsetInSavedWindow() + secondWord);
}
// Only the window'd GPRs get handled this way; not the globals.
return null;
}
protected void initializePD() {
window = null;
youngerWindow = null;
// avoid the shift_individual_registers game
makeIntegerRegsUnsaved();
}
protected void initializeFromPD(RegisterMap map) {
SPARCRegisterMap srm = (SPARCRegisterMap) map;
window = srm.window;
youngerWindow = srm.youngerWindow;
// avoid the shift_individual_registers game
makeIntegerRegsUnsaved();
}
public void shiftWindow(Address sp, Address youngerSP) {
window = sp;
youngerWindow = youngerSP;
// Throw away locations for %i, %o, and %l registers:
// But do not throw away %g register locs.
if (locationValid[0] != 0) {
shiftIndividualRegisters();
}
}
/** When popping out of compiled frames, we make all IRegs disappear. */
public void makeIntegerRegsUnsaved() {
locationValid[0] = 0;
}
//--------------------------------------------------------------------------------
// Internals only below this point
//
private void shiftIndividualRegisters() {
if (!getUpdateMap()) {
return;
}
checkLocationValid();
long lv = locationValid[0];
long lv0 = lv;
lv &= ~R_LIO_mask; // clear %l, %o, %i regs
// if we cleared some non-%g locations, we may have to do some shifting
if (lv != lv0) {
// copy %i0-%i5 to %o0-%o5, if they have special locations
// This can happen in within stubs which spill argument registers
// around a dynamic link operation, such as resolve_opt_virtual_call.
for (int i = 0; i < 8; i++) {
if ((lv0 & ((long) 1 << R_I_nums[i])) != 0) {
location[R_O_nums[i]] = location[R_I_nums[i]];
lv |= ((long) 1 << R_O_nums[i]);
}
}
}
locationValid[0] = lv;
checkLocationValid();
}
private boolean isEven(int i) {
return (i & 1) == 0;
}
private void checkLocationValid() {
if (Assert.ASSERTS_ENABLED) {
Assert.that((locationValid[0] & badMask) == 0, "cannot have special locations for SP,FP,TLS,etc.");
}
}
}