1
|
1 |
/*
|
|
2 |
* Copyright 2000-2006 Sun Microsystems, Inc. All Rights Reserved.
|
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
4 |
*
|
|
5 |
* This code is free software; you can redistribute it and/or modify it
|
|
6 |
* under the terms of the GNU General Public License version 2 only, as
|
|
7 |
* published by the Free Software Foundation.
|
|
8 |
*
|
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that
|
|
13 |
* accompanied this code).
|
|
14 |
*
|
|
15 |
* You should have received a copy of the GNU General Public License version
|
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
18 |
*
|
|
19 |
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
20 |
* CA 95054 USA or visit www.sun.com if you need additional information or
|
|
21 |
* have any questions.
|
|
22 |
*
|
|
23 |
*/
|
|
24 |
|
|
25 |
package sun.jvm.hotspot.compiler;
|
|
26 |
|
|
27 |
import java.util.*;
|
|
28 |
|
|
29 |
import sun.jvm.hotspot.code.*;
|
|
30 |
import sun.jvm.hotspot.runtime.*;
|
|
31 |
import sun.jvm.hotspot.types.*;
|
|
32 |
import sun.jvm.hotspot.utilities.*;
|
|
33 |
|
|
34 |
public class OopMapValue {
|
|
35 |
private short value;
|
|
36 |
private short contentReg;
|
|
37 |
|
|
38 |
/** Read from target VM; located in compiler/oopMap.hpp */
|
|
39 |
// How bits are organized
|
|
40 |
static int TYPE_BITS;
|
|
41 |
static int REGISTER_BITS;
|
|
42 |
static int TYPE_SHIFT;
|
|
43 |
static int REGISTER_SHIFT;
|
|
44 |
static int TYPE_MASK;
|
|
45 |
static int TYPE_MASK_IN_PLACE;
|
|
46 |
static int REGISTER_MASK;
|
|
47 |
static int REGISTER_MASK_IN_PLACE;
|
|
48 |
|
|
49 |
// Types of OopValues
|
|
50 |
static int UNUSED_VALUE;
|
|
51 |
static int OOP_VALUE;
|
|
52 |
static int VALUE_VALUE;
|
|
53 |
static int DEAD_VALUE;
|
|
54 |
static int CALLEE_SAVED_VALUE;
|
|
55 |
static int DERIVED_OOP_VALUE;
|
|
56 |
|
|
57 |
static {
|
|
58 |
VM.registerVMInitializedObserver(new Observer() {
|
|
59 |
public void update(Observable o, Object data) {
|
|
60 |
initialize(VM.getVM().getTypeDataBase());
|
|
61 |
}
|
|
62 |
});
|
|
63 |
}
|
|
64 |
|
|
65 |
private static void initialize(TypeDataBase db) {
|
|
66 |
TYPE_BITS = db.lookupIntConstant("OopMapValue::type_bits").intValue();
|
|
67 |
REGISTER_BITS = db.lookupIntConstant("OopMapValue::register_bits").intValue();
|
|
68 |
TYPE_SHIFT = db.lookupIntConstant("OopMapValue::type_shift").intValue();
|
|
69 |
REGISTER_SHIFT = db.lookupIntConstant("OopMapValue::register_shift").intValue();
|
|
70 |
TYPE_MASK = db.lookupIntConstant("OopMapValue::type_mask").intValue();
|
|
71 |
TYPE_MASK_IN_PLACE = db.lookupIntConstant("OopMapValue::type_mask_in_place").intValue();
|
|
72 |
REGISTER_MASK = db.lookupIntConstant("OopMapValue::register_mask").intValue();
|
|
73 |
REGISTER_MASK_IN_PLACE = db.lookupIntConstant("OopMapValue::register_mask_in_place").intValue();
|
|
74 |
UNUSED_VALUE = db.lookupIntConstant("OopMapValue::unused_value").intValue();
|
|
75 |
OOP_VALUE = db.lookupIntConstant("OopMapValue::oop_value").intValue();
|
|
76 |
VALUE_VALUE = db.lookupIntConstant("OopMapValue::value_value").intValue();
|
|
77 |
DEAD_VALUE = db.lookupIntConstant("OopMapValue::dead_value").intValue();
|
|
78 |
CALLEE_SAVED_VALUE = db.lookupIntConstant("OopMapValue::callee_saved_value").intValue();
|
|
79 |
DERIVED_OOP_VALUE = db.lookupIntConstant("OopMapValue::derived_oop_value").intValue();
|
|
80 |
}
|
|
81 |
|
|
82 |
public static abstract class OopTypes {
|
|
83 |
public static final OopTypes UNUSED_VALUE = new OopTypes() { int getValue() { return OopMapValue.UNUSED_VALUE; }};
|
|
84 |
public static final OopTypes OOP_VALUE = new OopTypes() { int getValue() { return OopMapValue.OOP_VALUE; }};
|
|
85 |
public static final OopTypes VALUE_VALUE = new OopTypes() { int getValue() { return OopMapValue.VALUE_VALUE; }};
|
|
86 |
public static final OopTypes DEAD_VALUE = new OopTypes() { int getValue() { return OopMapValue.DEAD_VALUE; }};
|
|
87 |
public static final OopTypes CALLEE_SAVED_VALUE = new OopTypes() { int getValue() { return OopMapValue.CALLEE_SAVED_VALUE; }};
|
|
88 |
public static final OopTypes DERIVED_OOP_VALUE = new OopTypes() { int getValue() { return OopMapValue.DERIVED_OOP_VALUE; }};
|
|
89 |
|
|
90 |
abstract int getValue();
|
|
91 |
protected OopTypes() {}
|
|
92 |
}
|
|
93 |
|
|
94 |
public OopMapValue() { setValue((short) 0); setContentReg(new VMReg(0)); }
|
|
95 |
public OopMapValue(VMReg reg, OopTypes t) { setReg(reg); setType(t); }
|
|
96 |
public OopMapValue(VMReg reg, OopTypes t, VMReg reg2) { setReg(reg); setType(t); setContentReg(reg2); }
|
|
97 |
public OopMapValue(CompressedReadStream stream) { readFrom(stream); }
|
|
98 |
|
|
99 |
public void readFrom(CompressedReadStream stream) {
|
|
100 |
setValue((short) stream.readInt());
|
|
101 |
if (isCalleeSaved() || isDerivedOop()) {
|
|
102 |
setContentReg(new VMReg(stream.readInt()));
|
|
103 |
}
|
|
104 |
}
|
|
105 |
|
|
106 |
// Querying
|
|
107 |
public boolean isOop() { return (getValue() & TYPE_MASK_IN_PLACE) == OOP_VALUE; }
|
|
108 |
public boolean isValue() { return (getValue() & TYPE_MASK_IN_PLACE) == VALUE_VALUE; }
|
|
109 |
public boolean isDead() { return (getValue() & TYPE_MASK_IN_PLACE) == DEAD_VALUE; }
|
|
110 |
public boolean isCalleeSaved() { return (getValue() & TYPE_MASK_IN_PLACE) == CALLEE_SAVED_VALUE; }
|
|
111 |
public boolean isDerivedOop() { return (getValue() & TYPE_MASK_IN_PLACE) == DERIVED_OOP_VALUE; }
|
|
112 |
|
|
113 |
public VMReg getReg() { return new VMReg((getValue() & REGISTER_MASK_IN_PLACE) >> REGISTER_SHIFT); }
|
|
114 |
public void setReg(VMReg r) { setValue((short) (r.getValue() << REGISTER_SHIFT | (getValue() & TYPE_MASK_IN_PLACE))); }
|
|
115 |
|
|
116 |
public OopTypes getType() {
|
|
117 |
int which = (getValue() & TYPE_MASK_IN_PLACE);
|
|
118 |
if (which == UNUSED_VALUE) return OopTypes.UNUSED_VALUE;
|
|
119 |
else if (which == OOP_VALUE) return OopTypes.OOP_VALUE;
|
|
120 |
else if (which == VALUE_VALUE) return OopTypes.VALUE_VALUE;
|
|
121 |
else if (which == DEAD_VALUE) return OopTypes.DEAD_VALUE;
|
|
122 |
else if (which == CALLEE_SAVED_VALUE) return OopTypes.CALLEE_SAVED_VALUE;
|
|
123 |
else if (which == DERIVED_OOP_VALUE) return OopTypes.DERIVED_OOP_VALUE;
|
|
124 |
else throw new InternalError("unknown which " + which + " (TYPE_MASK_IN_PLACE = " + TYPE_MASK_IN_PLACE + ")");
|
|
125 |
}
|
|
126 |
public void setType(OopTypes t) { setValue((short) ((getValue() & REGISTER_MASK_IN_PLACE) | t.getValue())); }
|
|
127 |
|
|
128 |
public VMReg getContentReg() { return new VMReg(contentReg); }
|
|
129 |
public void setContentReg(VMReg r) { contentReg = (short) r.getValue(); }
|
|
130 |
|
|
131 |
/** Physical location queries */
|
|
132 |
public boolean isRegisterLoc() { return (getReg().lessThan(VM.getVM().getVMRegImplInfo().getStack0())); }
|
|
133 |
public boolean isStackLoc() { return (getReg().greaterThanOrEqual(VM.getVM().getVMRegImplInfo().getStack0())); }
|
|
134 |
|
|
135 |
/** Returns offset from sp. */
|
|
136 |
public int getStackOffset() {
|
|
137 |
if (Assert.ASSERTS_ENABLED) {
|
|
138 |
Assert.that(isStackLoc(), "must be stack location");
|
|
139 |
}
|
|
140 |
return getReg().minus(VM.getVM().getVMRegImplInfo().getStack0());
|
|
141 |
}
|
|
142 |
|
|
143 |
//--------------------------------------------------------------------------------
|
|
144 |
// Internals only below this point
|
|
145 |
//
|
|
146 |
|
|
147 |
private void setValue(short value) {
|
|
148 |
this.value = value;
|
|
149 |
}
|
|
150 |
|
|
151 |
private int getValue() {
|
|
152 |
return value;
|
|
153 |
}
|
|
154 |
}
|