1 /*
2 * Copyright 2000-2005 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.code;
26
27 import java.io.*;
28 import java.util.*;
29
30 import sun.jvm.hotspot.runtime.*;
31 import sun.jvm.hotspot.types.*;
32 import sun.jvm.hotspot.utilities.*;
33
34 /** <P> A Location describes a concrete machine variable location
35 (such as integer or floating point register or a stack-held
36 variable). Used when generating debug-information for
37 nmethods. </P>
38
39 <P> Encoding: </P>
40 <PRE>
41 bits:
42 Where: [15]
43 Type: [14..12]
44 Offset: [11..0]
45 </PRE>
46 */
47
48 public class Location {
49 static {
50 VM.registerVMInitializedObserver(new Observer() {
51 public void update(Observable o, Object data) {
52 initialize(VM.getVM().getTypeDataBase());
53 }
54 });
55 }
56
57 private static void initialize(TypeDataBase db) {
58 if (Assert.ASSERTS_ENABLED) {
59 Assert.that(!VM.getVM().isCore(), "Debug info not used in core build");
60 }
61
62 OFFSET_MASK = db.lookupIntConstant("Location::OFFSET_MASK").intValue();
63 OFFSET_SHIFT = db.lookupIntConstant("Location::OFFSET_SHIFT").intValue();
64 TYPE_MASK = db.lookupIntConstant("Location::TYPE_MASK").intValue();
65 TYPE_SHIFT = db.lookupIntConstant("Location::TYPE_SHIFT").intValue();
66 WHERE_MASK = db.lookupIntConstant("Location::WHERE_MASK").intValue();
67 WHERE_SHIFT = db.lookupIntConstant("Location::WHERE_SHIFT").intValue();
68
69 // Location::Type constants
70 TYPE_NORMAL = db.lookupIntConstant("Location::normal").intValue();
71 TYPE_OOP = db.lookupIntConstant("Location::oop").intValue();
72 TYPE_INT_IN_LONG = db.lookupIntConstant("Location::int_in_long").intValue();
73 TYPE_LNG = db.lookupIntConstant("Location::lng").intValue();
74 TYPE_FLOAT_IN_DBL = db.lookupIntConstant("Location::float_in_dbl").intValue();
75 TYPE_DBL = db.lookupIntConstant("Location::dbl").intValue();
76 TYPE_ADDR = db.lookupIntConstant("Location::addr").intValue();
77 TYPE_INVALID = db.lookupIntConstant("Location::invalid").intValue();
78
79 // Location::Where constants
80 WHERE_ON_STACK = db.lookupIntConstant("Location::on_stack").intValue();
81 WHERE_IN_REGISTER = db.lookupIntConstant("Location::in_register").intValue();
82 }
83
84 private int value;
85
86 // type safe enum for "Where"
87 public static class Where {
88 public static final Where ON_STACK = new Where("on_stack");
89 public static final Where IN_REGISTER = new Where("in_register");
90
91 private Where(String value) {
98
99 private String value;
100
101 public int getValue() {
102 if (this == ON_STACK) {
103 return WHERE_ON_STACK;
104 } else if (this == IN_REGISTER) {
105 return WHERE_IN_REGISTER;
106 } else {
107 throw new RuntimeException("should not reach here");
108 }
109 }
110 }
111
112 // type safe enum for "Type"
113 public static class Type {
114 /** Ints, floats, double halves */
115 public static final Type NORMAL = new Type("normal");
116 /** Oop (please GC me!) */
117 public static final Type OOP = new Type("oop");
118 /** Long held in one register */
119 public static final Type INT_IN_LONG = new Type("int_in_long");
120 /** Long held in one register */
121 public static final Type LNG = new Type("lng");
122 /** Float held in double register */
123 public static final Type FLOAT_IN_DBL = new Type("float_in_dbl");
124 /** Double held in one register */
125 public static final Type DBL = new Type("dbl");
126 /** JSR return address */
127 public static final Type ADDR = new Type("addr");
128 /** Invalid location */
129 public static final Type INVALID = new Type("invalid");
130
131 private Type(String value) {
132 this.value = value;
133 }
134 private String value;
135
136 public String toString() {
137 return value;
138 }
139
140 public int getValue() {
141 if (this == NORMAL) {
142 return TYPE_NORMAL;
143 } else if (this == OOP) {
144 return TYPE_OOP;
145 } else if (this == INT_IN_LONG) {
146 return TYPE_INT_IN_LONG;
147 } else if (this == LNG) {
148 return TYPE_LNG;
149 } else if (this == FLOAT_IN_DBL) {
150 return TYPE_FLOAT_IN_DBL;
151 } else if (this == DBL) {
152 return TYPE_DBL;
153 } else if (this == ADDR) {
154 return TYPE_ADDR;
155 } else if (this == INVALID) {
156 return TYPE_INVALID;
157 } else {
158 throw new RuntimeException("should not reach here");
159 }
160 }
161 }
162
163 private static int OFFSET_MASK;
164 private static int OFFSET_SHIFT;
165 private static int TYPE_MASK;
166 private static int TYPE_SHIFT;
167 private static int WHERE_MASK;
168 private static int WHERE_SHIFT;
169
170 // constants in Type enum
171 private static int TYPE_NORMAL;
172 private static int TYPE_OOP;
173 private static int TYPE_INT_IN_LONG;
174 private static int TYPE_LNG;
175 private static int TYPE_FLOAT_IN_DBL;
176 private static int TYPE_DBL;
177 private static int TYPE_ADDR;
178 private static int TYPE_INVALID;
179
180 // constants in Where enum
181 private static int WHERE_ON_STACK;
182 private static int WHERE_IN_REGISTER;
183
184 /** Create a bit-packed Location */
185 Location(Where where, Type type, int offset) {
186 setWhere(where);
187 setType(type);
188 setOffset(offset & 0x0000FFFF);
189 }
190
191 public Where getWhere() {
192 int where = (value & WHERE_MASK) >> WHERE_SHIFT;
193 if (where == WHERE_ON_STACK) {
194 return Where.ON_STACK;
195 } else if (where == WHERE_IN_REGISTER) {
196 return Where.IN_REGISTER;
197 } else {
198 throw new RuntimeException("should not reach here");
199 }
200 }
201
202 public Type getType() {
203 int type = (value & TYPE_MASK) >> TYPE_SHIFT;
204 if (type == TYPE_NORMAL) {
205 return Type.NORMAL;
206 } else if (type == TYPE_OOP) {
207 return Type.OOP;
208 } else if (type == TYPE_INT_IN_LONG) {
209 return Type.INT_IN_LONG;
210 } else if (type == TYPE_LNG) {
211 return Type.LNG;
212 } else if (type == TYPE_FLOAT_IN_DBL) {
213 return Type.FLOAT_IN_DBL;
214 } else if (type == TYPE_DBL) {
215 return Type.DBL;
216 } else if (type == TYPE_ADDR) {
217 return Type.ADDR;
218 } else if (type == TYPE_INVALID) {
219 return Type.INVALID;
220 } else {
221 throw new RuntimeException("should not reach here");
222 }
223 }
224
225 public short getOffset() {
226 return (short) ((value & OFFSET_MASK) >> OFFSET_SHIFT);
227 }
228
229 public boolean isRegister() {
230 return getWhere() == Where.IN_REGISTER;
231 }
232
233 public boolean isStack() {
234 return getWhere() == Where.ON_STACK;
235 }
236
237 public boolean holdsOop() {
238 return getType() == Type.OOP;
239 }
240
241 public boolean holdsInt() {
242 return getType() == Type.INT_IN_LONG;
243 }
244
245 public boolean holdsLong() {
246 return getType() == Type.LNG;
247 }
248
249 public boolean holdsFloat() {
250 return getType() == Type.FLOAT_IN_DBL;
251 }
252
253 public boolean holdsDouble() {
254 return getType() == Type.DBL;
255 }
256
257 public boolean holdsAddr() {
258 return getType() == Type.ADDR;
259 }
260
261 public boolean isIllegal() {
262 return getType() == Type.INVALID;
263 }
264
265 public int getStackOffset() {
266 if (Assert.ASSERTS_ENABLED) {
267 Assert.that(getWhere() == Where.ON_STACK, "wrong Where");
268 }
269 return getOffset() << VM.getVM().getLogAddressSize();
270 }
271
272 public int getRegisterNumber() {
273 if (Assert.ASSERTS_ENABLED) {
274 Assert.that(getWhere() == Where.IN_REGISTER, "wrong Where");
275 }
276 return getOffset();
277 }
278
279 public void print() {
280 printOn(System.out);
281 }
282
283 public void printOn(PrintStream tty) {
284 tty.print("Value " + value + ", ");
285 if (isIllegal()) {
286 tty.print("Illegal");
287 } else {
288 Where w = getWhere();
289 if (w == Where.ON_STACK) {
290 tty.print("stack[" + getStackOffset() + "]");
291 } else if (w == Where.IN_REGISTER) {
292 tty.print("reg " + getRegisterNumber());
293 }
294
295 Type type = getType();
296 if (type == Type.NORMAL) {
297 } else if (type == Type.OOP) {
298 tty.print(",oop");
299 } else if (type == Type.INT_IN_LONG) {
300 tty.print(",int");
301 } else if (type == Type.LNG) {
302 tty.print(",long");
303 } else if (type == Type.FLOAT_IN_DBL) {
304 tty.print(",float");
305 } else if (type == Type.DBL) {
306 tty.print(",double");
307 } else if (type == Type.ADDR) {
308 tty.print(",address");
309 } else if (type == Type.INVALID) {
310 tty.print(",invalid");
311 }
312 }
313 }
314
315 /** Serialization of debugging information */
316 public Location(DebugInfoReadStream stream) {
317 value = (0x0000FFFF & stream.readInt());
318 }
319
320 // FIXME: not yet implementable
321 // void write_on(DebugInfoWriteStream* stream);
322
323
324 //--------------------------------------------------------------------------------
325 // Internals only below this point
326 //
327
328 private void setWhere(Where where) {
329 value |= (where.getValue() << WHERE_SHIFT);
330 }
331
332 private void setType(Type type) {
333 value |= (type.getValue() << TYPE_SHIFT);
334 }
335
336 private void setOffset(int offset) {
337 value |= (offset << OFFSET_SHIFT);
338 }
339 }
|
1 /*
2 * Copyright 2000-2008 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.code;
26
27 import java.io.*;
28 import java.util.*;
29
30 import sun.jvm.hotspot.runtime.*;
31 import sun.jvm.hotspot.types.*;
32 import sun.jvm.hotspot.utilities.*;
33
34 /** <P> A Location describes a concrete machine variable location
35 (such as integer or floating point register or a stack-held
36 variable). Used when generating debug-information for
37 nmethods. </P>
38
39 <P> Encoding: </P>
40 <PRE>
41 bits:
42 Type: [3..0]
43 Where: [4]
44 Offset: [31..5]
45 </PRE>
46 */
47
48 public class Location {
49 static {
50 VM.registerVMInitializedObserver(new Observer() {
51 public void update(Observable o, Object data) {
52 initialize(VM.getVM().getTypeDataBase());
53 }
54 });
55 }
56
57 private static void initialize(TypeDataBase db) {
58 if (Assert.ASSERTS_ENABLED) {
59 Assert.that(!VM.getVM().isCore(), "Debug info not used in core build");
60 }
61
62 OFFSET_MASK = db.lookupIntConstant("Location::OFFSET_MASK").intValue();
63 OFFSET_SHIFT = db.lookupIntConstant("Location::OFFSET_SHIFT").intValue();
64 TYPE_MASK = db.lookupIntConstant("Location::TYPE_MASK").intValue();
65 TYPE_SHIFT = db.lookupIntConstant("Location::TYPE_SHIFT").intValue();
66 WHERE_MASK = db.lookupIntConstant("Location::WHERE_MASK").intValue();
67 WHERE_SHIFT = db.lookupIntConstant("Location::WHERE_SHIFT").intValue();
68
69 // Location::Type constants
70 TYPE_NORMAL = db.lookupIntConstant("Location::normal").intValue();
71 TYPE_OOP = db.lookupIntConstant("Location::oop").intValue();
72 TYPE_NARROWOOP = db.lookupIntConstant("Location::narrowoop").intValue();
73 TYPE_INT_IN_LONG = db.lookupIntConstant("Location::int_in_long").intValue();
74 TYPE_LNG = db.lookupIntConstant("Location::lng").intValue();
75 TYPE_FLOAT_IN_DBL = db.lookupIntConstant("Location::float_in_dbl").intValue();
76 TYPE_DBL = db.lookupIntConstant("Location::dbl").intValue();
77 TYPE_ADDR = db.lookupIntConstant("Location::addr").intValue();
78 TYPE_INVALID = db.lookupIntConstant("Location::invalid").intValue();
79
80 // Location::Where constants
81 WHERE_ON_STACK = db.lookupIntConstant("Location::on_stack").intValue();
82 WHERE_IN_REGISTER = db.lookupIntConstant("Location::in_register").intValue();
83 }
84
85 private int value;
86
87 // type safe enum for "Where"
88 public static class Where {
89 public static final Where ON_STACK = new Where("on_stack");
90 public static final Where IN_REGISTER = new Where("in_register");
91
92 private Where(String value) {
99
100 private String value;
101
102 public int getValue() {
103 if (this == ON_STACK) {
104 return WHERE_ON_STACK;
105 } else if (this == IN_REGISTER) {
106 return WHERE_IN_REGISTER;
107 } else {
108 throw new RuntimeException("should not reach here");
109 }
110 }
111 }
112
113 // type safe enum for "Type"
114 public static class Type {
115 /** Ints, floats, double halves */
116 public static final Type NORMAL = new Type("normal");
117 /** Oop (please GC me!) */
118 public static final Type OOP = new Type("oop");
119 /** NarrowOop (please GC me!) */
120 public static final Type NARROWOOP = new Type("narrowoop");
121 /** Long held in one register */
122 public static final Type INT_IN_LONG = new Type("int_in_long");
123 /** Long held in one register */
124 public static final Type LNG = new Type("lng");
125 /** Float held in double register */
126 public static final Type FLOAT_IN_DBL = new Type("float_in_dbl");
127 /** Double held in one register */
128 public static final Type DBL = new Type("dbl");
129 /** JSR return address */
130 public static final Type ADDR = new Type("addr");
131 /** Invalid location */
132 public static final Type INVALID = new Type("invalid");
133
134 private Type(String value) {
135 this.value = value;
136 }
137 private String value;
138
139 public String toString() {
140 return value;
141 }
142
143 public int getValue() {
144 if (this == NORMAL) {
145 return TYPE_NORMAL;
146 } else if (this == OOP) {
147 return TYPE_OOP;
148 } else if (this == NARROWOOP) {
149 return TYPE_NARROWOOP;
150 } else if (this == INT_IN_LONG) {
151 return TYPE_INT_IN_LONG;
152 } else if (this == LNG) {
153 return TYPE_LNG;
154 } else if (this == FLOAT_IN_DBL) {
155 return TYPE_FLOAT_IN_DBL;
156 } else if (this == DBL) {
157 return TYPE_DBL;
158 } else if (this == ADDR) {
159 return TYPE_ADDR;
160 } else if (this == INVALID) {
161 return TYPE_INVALID;
162 } else {
163 throw new RuntimeException("should not reach here");
164 }
165 }
166 }
167
168 private static int OFFSET_MASK;
169 private static int OFFSET_SHIFT;
170 private static int TYPE_MASK;
171 private static int TYPE_SHIFT;
172 private static int WHERE_MASK;
173 private static int WHERE_SHIFT;
174
175 // constants in Type enum
176 private static int TYPE_NORMAL;
177 private static int TYPE_OOP;
178 private static int TYPE_NARROWOOP;
179 private static int TYPE_INT_IN_LONG;
180 private static int TYPE_LNG;
181 private static int TYPE_FLOAT_IN_DBL;
182 private static int TYPE_DBL;
183 private static int TYPE_ADDR;
184 private static int TYPE_INVALID;
185
186 // constants in Where enum
187 private static int WHERE_ON_STACK;
188 private static int WHERE_IN_REGISTER;
189
190 /** Create a bit-packed Location */
191 Location(Where where, Type type, int offset) {
192 setWhere(where);
193 setType(type);
194 setOffset(offset);
195 }
196
197 public Where getWhere() {
198 int where = (value & WHERE_MASK) >> WHERE_SHIFT;
199 if (where == WHERE_ON_STACK) {
200 return Where.ON_STACK;
201 } else if (where == WHERE_IN_REGISTER) {
202 return Where.IN_REGISTER;
203 } else {
204 throw new RuntimeException("should not reach here");
205 }
206 }
207
208 public Type getType() {
209 int type = (value & TYPE_MASK) >> TYPE_SHIFT;
210 if (type == TYPE_NORMAL) {
211 return Type.NORMAL;
212 } else if (type == TYPE_OOP) {
213 return Type.OOP;
214 } else if (type == TYPE_NARROWOOP) {
215 return Type.NARROWOOP;
216 } else if (type == TYPE_INT_IN_LONG) {
217 return Type.INT_IN_LONG;
218 } else if (type == TYPE_LNG) {
219 return Type.LNG;
220 } else if (type == TYPE_FLOAT_IN_DBL) {
221 return Type.FLOAT_IN_DBL;
222 } else if (type == TYPE_DBL) {
223 return Type.DBL;
224 } else if (type == TYPE_ADDR) {
225 return Type.ADDR;
226 } else if (type == TYPE_INVALID) {
227 return Type.INVALID;
228 } else {
229 throw new RuntimeException("should not reach here");
230 }
231 }
232
233 public short getOffset() {
234 return (short) ((value & OFFSET_MASK) >> OFFSET_SHIFT);
235 }
236
237 public boolean isRegister() {
238 return getWhere() == Where.IN_REGISTER;
239 }
240
241 public boolean isStack() {
242 return getWhere() == Where.ON_STACK;
243 }
244
245 public boolean holdsOop() {
246 return getType() == Type.OOP;
247 }
248
249 public boolean holdsNarrowOop() {
250 return getType() == Type.NARROWOOP;
251 }
252
253 public boolean holdsInt() {
254 return getType() == Type.INT_IN_LONG;
255 }
256
257 public boolean holdsLong() {
258 return getType() == Type.LNG;
259 }
260
261 public boolean holdsFloat() {
262 return getType() == Type.FLOAT_IN_DBL;
263 }
264
265 public boolean holdsDouble() {
266 return getType() == Type.DBL;
267 }
268
269 public boolean holdsAddr() {
270 return getType() == Type.ADDR;
271 }
272
273 public boolean isIllegal() {
274 return getType() == Type.INVALID;
275 }
276
277 public int getStackOffset() {
278 if (Assert.ASSERTS_ENABLED) {
279 Assert.that(getWhere() == Where.ON_STACK, "wrong Where");
280 }
281 return getOffset() * (int)VM.getVM().getIntSize();
282 }
283
284 public int getRegisterNumber() {
285 if (Assert.ASSERTS_ENABLED) {
286 Assert.that(getWhere() == Where.IN_REGISTER, "wrong Where");
287 }
288 return getOffset();
289 }
290
291 public void print() {
292 printOn(System.out);
293 }
294
295 public void printOn(PrintStream tty) {
296 tty.print("Value " + value + ", ");
297 if (isIllegal()) {
298 tty.print("Illegal");
299 } else {
300 Where w = getWhere();
301 if (w == Where.ON_STACK) {
302 tty.print("stack[" + getStackOffset() + "]");
303 } else if (w == Where.IN_REGISTER) {
304 tty.print("reg " + getRegisterNumber());
305 }
306
307 Type type = getType();
308 if (type == Type.NORMAL) {
309 } else if (type == Type.OOP) {
310 tty.print(",oop");
311 } else if (type == Type.NARROWOOP) {
312 tty.print(",narrowoop");
313 } else if (type == Type.INT_IN_LONG) {
314 tty.print(",int");
315 } else if (type == Type.LNG) {
316 tty.print(",long");
317 } else if (type == Type.FLOAT_IN_DBL) {
318 tty.print(",float");
319 } else if (type == Type.DBL) {
320 tty.print(",double");
321 } else if (type == Type.ADDR) {
322 tty.print(",address");
323 } else if (type == Type.INVALID) {
324 tty.print(",invalid");
325 }
326 }
327 }
328
329 /** Serialization of debugging information */
330 public Location(DebugInfoReadStream stream) {
331 value = stream.readInt();
332 }
333
334 // FIXME: not yet implementable
335 // void write_on(DebugInfoWriteStream* stream);
336
337
338 //-----------------------------------------------------------------------------
339 // Internals only below this point
340 //
341
342 private void setWhere(Where where) {
343 value |= ((where.getValue() << WHERE_SHIFT) & WHERE_MASK);
344 }
345
346 private void setType(Type type) {
347 value |= ((type.getValue() << TYPE_SHIFT) & TYPE_MASK);
348 }
349
350 private void setOffset(int offset) {
351 value |= ((offset << OFFSET_SHIFT) & OFFSET_MASK);
352 }
353 }
|