/*
* Copyright (c) 2001, 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.oops;
import java.io.*;
import sun.jvm.hotspot.utilities.*;
/** Auxiliary class for GenerateOopMap */
public class CellTypeState {
private int _state;
// Masks for separating the BITS and INFO portions of a
// CellTypeState
private static final int info_mask = Bits.rightNBits(28);
private static final int bits_mask = ~info_mask;
// These constant are used for manipulating the BITS portion of a
// CellTypeState
private static final int uninit_bit = Bits.nthBit(31);
private static final int ref_bit = Bits.nthBit(30);
private static final int val_bit = Bits.nthBit(29);
private static final int addr_bit = Bits.nthBit(28);
private static final int live_bits_mask = bits_mask & ~uninit_bit;
// These constants are used for manipulating the INFO portion of a
// CellTypeState
private static final int top_info_bit = Bits.nthBit(27);
private static final int not_bottom_info_bit = Bits.nthBit(26);
private static final int info_data_mask = Bits.rightNBits(26);
private static final int info_conflict = info_mask;
// Within the INFO data, these values are used to distinguish
// different kinds of references.
// 0 if this reference is locked as a monitor
private static final int ref_not_lock_bit = Bits.nthBit(25);
// 1 if this reference is a "slot" reference
private static final int ref_slot_bit = Bits.nthBit(24);
// 0 if it is a "line" reference.
private static final int ref_data_mask = Bits.rightNBits(24);
// These values are used to initialize commonly used CellTypeState
// constants.
private static final int bottom_value = 0;
private static final int uninit_value = uninit_bit | info_conflict;
private static final int ref_value = ref_bit;
private static final int ref_conflict = ref_bit | info_conflict;
private static final int val_value = val_bit | info_conflict;
private static final int addr_value = addr_bit;
private static final int addr_conflict = addr_bit | info_conflict;
private CellTypeState() {}
private CellTypeState(int state) {
_state = state;
}
public CellTypeState copy() {
return new CellTypeState(_state);
}
public static CellTypeState makeAny(int state) {
CellTypeState s = new CellTypeState(state);
if (Assert.ASSERTS_ENABLED) {
Assert.that(s.isValidState(), "check to see if CellTypeState is valid");
}
return s;
}
public static CellTypeState makeBottom() {
return makeAny(0);
}
public static CellTypeState makeTop() {
return makeAny(Bits.AllBits);
}
public static CellTypeState makeAddr(int bci) {
if (Assert.ASSERTS_ENABLED) {
Assert.that((bci >= 0) && (bci < info_data_mask),
"check to see if ret addr is valid");
}
return makeAny(addr_bit | not_bottom_info_bit | (bci & info_data_mask));
}
public static CellTypeState makeSlotRef(int slot_num) {
if (Assert.ASSERTS_ENABLED) {
Assert.that(slot_num >= 0 && slot_num < ref_data_mask, "slot out of range");
}
return makeAny(ref_bit | not_bottom_info_bit | ref_not_lock_bit | ref_slot_bit |
(slot_num & ref_data_mask));
}
public static CellTypeState makeLineRef(int bci) {
if (Assert.ASSERTS_ENABLED) {
Assert.that(bci >= 0 && bci < ref_data_mask, "line out of range");
}
return makeAny(ref_bit | not_bottom_info_bit | ref_not_lock_bit |
(bci & ref_data_mask));
}
public static CellTypeState makeLockRef(int bci) {
if (Assert.ASSERTS_ENABLED) {
Assert.that(bci >= 0 && bci < ref_data_mask, "line out of range");
}
return makeAny(ref_bit | not_bottom_info_bit | (bci & ref_data_mask));
}
// Query methods:
public boolean isBottom() { return _state == 0; }
public boolean isLive() { return ((_state & live_bits_mask) != 0); }
public boolean isValidState() {
// Uninitialized and value cells must contain no data in their info field:
if ((canBeUninit() || canBeValue()) && !isInfoTop()) {
return false;
}
// The top bit is only set when all info bits are set:
if (isInfoTop() && ((_state & info_mask) != info_mask)) {
return false;
}
// The not_bottom_bit must be set when any other info bit is set:
if (isInfoBottom() && ((_state & info_mask) != 0)) {
return false;
}
return true;
}
public boolean isAddress() { return ((_state & bits_mask) == addr_bit); }
public boolean isReference() { return ((_state & bits_mask) == ref_bit); }
public boolean isValue() { return ((_state & bits_mask) == val_bit); }
public boolean isUninit() { return ((_state & bits_mask) == uninit_bit); }
public boolean canBeAddress() { return ((_state & addr_bit) != 0); }
public boolean canBeReference() { return ((_state & ref_bit) != 0); }
public boolean canBeValue() { return ((_state & val_bit) != 0); }
public boolean canBeUninit() { return ((_state & uninit_bit) != 0); }
public boolean isInfoBottom() { return ((_state & not_bottom_info_bit) == 0); }
public boolean isInfoTop() { return ((_state & top_info_bit) != 0); }
public int getInfo() {
if (Assert.ASSERTS_ENABLED) {
Assert.that((!isInfoTop() && !isInfoBottom()),
"check to make sure top/bottom info is not used");
}
return (_state & info_data_mask);
}
public int getMonitorSource() {
if (Assert.ASSERTS_ENABLED) {
Assert.that(isLockReference(), "must be lock");
}
return getInfo();
}
public boolean isGoodAddress() { return isAddress() && !isInfoTop(); }
public boolean isLockReference() {
return ((_state & (bits_mask | top_info_bit | ref_not_lock_bit)) == ref_bit);
}
public boolean isNonlockReference() {
return ((_state & (bits_mask | top_info_bit | ref_not_lock_bit)) == (ref_bit | ref_not_lock_bit));
}
public boolean equal(CellTypeState a) { return _state == a._state; }
public boolean equalKind(CellTypeState a) {
return (_state & bits_mask) == (a._state & bits_mask);
}
public char toChar() {
if (canBeReference()) {
if (canBeValue() || canBeAddress())
return '#'; // Conflict that needs to be rewritten
else
return 'r';
} else if (canBeValue())
return 'v';
else if (canBeAddress())
return 'p';
else if (canBeUninit())
return ' ';
else
return '@';
}
// Set
public void set(CellTypeState cts) {
_state = cts._state;
}
// Merge
public CellTypeState merge (CellTypeState cts, int slot) {
CellTypeState result = new CellTypeState();
if (Assert.ASSERTS_ENABLED) {
Assert.that(!isBottom() && !cts.isBottom(),
"merge of bottom values is handled elsewhere");
}
result._state = _state | cts._state;
// If the top bit is set, we don't need to do any more work.
if (!result.isInfoTop()) {
Assert.that((result.canBeAddress() || result.canBeReference()),
"only addresses and references have non-top info");
if (!equal(cts)) {
// The two values being merged are different. Raise to top.
if (result.isReference()) {
result = CellTypeState.makeSlotRef(slot);
} else {
result._state |= info_conflict;
}
}
}
if (Assert.ASSERTS_ENABLED) {
Assert.that(result.isValidState(), "checking that CTS merge maintains legal state");
}
return result;
}
// Debugging output
public void print(PrintStream tty) {
if (canBeAddress()) {
tty.print("(p");
} else {
tty.print("( ");
}
if (canBeReference()) {
tty.print("r");
} else {
tty.print(" ");
}
if (canBeValue()) {
tty.print("v");
} else {
tty.print(" ");
}
if (canBeUninit()) {
tty.print("u|");
} else {
tty.print(" |");
}
if (isInfoTop()) {
tty.print("Top)");
} else if (isInfoBottom()) {
tty.print("Bot)");
} else {
if (isReference()) {
int info = getInfo();
int data = info & ~(ref_not_lock_bit | ref_slot_bit);
if ((info & ref_not_lock_bit) != 0) {
// Not a monitor lock reference.
if ((info & ref_slot_bit) != 0) {
// slot
tty.print("slot" + data + ")");
} else {
// line
tty.print("line" + data + ")");
}
} else {
// lock
tty.print("lock" + data + ")");
}
} else {
tty.print("" + getInfo() + ")");
}
}
}
// Default values of common values
public static CellTypeState bottom = CellTypeState.makeBottom();
public static CellTypeState uninit = CellTypeState.makeAny(uninit_value);
public static CellTypeState ref = CellTypeState.makeAny(ref_conflict);
public static CellTypeState value = CellTypeState.makeAny(val_value);
public static CellTypeState refUninit = CellTypeState.makeAny(ref_conflict | uninit_value);
public static CellTypeState top = CellTypeState.makeTop();
public static CellTypeState addr = CellTypeState.makeAny(addr_conflict);
}