191 } else {
192 heapOopSize = oopSize;
193 LogBytesPerHeapOop = LogBytesPerWord;
194 LogBitsPerHeapOop = LogBitsPerWord;
195 BytesPerHeapOop = BytesPerWord;
196 BitsPerHeapOop = BitsPerWord;
197 }
198 _type2aelembytes[T_OBJECT] = heapOopSize;
199 _type2aelembytes[T_ARRAY] = heapOopSize;
200 }
201
202
203 // Map BasicType to signature character
204 char type2char_tab[T_CONFLICT+1] = {
205 0, 0, 0, 0,
206 JVM_SIGNATURE_BOOLEAN, JVM_SIGNATURE_CHAR,
207 JVM_SIGNATURE_FLOAT, JVM_SIGNATURE_DOUBLE,
208 JVM_SIGNATURE_BYTE, JVM_SIGNATURE_SHORT,
209 JVM_SIGNATURE_INT, JVM_SIGNATURE_LONG,
210 JVM_SIGNATURE_CLASS, JVM_SIGNATURE_ARRAY,
211 JVM_SIGNATURE_VOID, 0,
212 0, 0, 0, 0
213 };
214
215 // Map BasicType to Java type name
216 const char* type2name_tab[T_CONFLICT+1] = {
217 nullptr, nullptr, nullptr, nullptr,
218 "boolean",
219 "char",
220 "float",
221 "double",
222 "byte",
223 "short",
224 "int",
225 "long",
226 "object",
227 "array",
228 "void",
229 "*address*",
230 "*narrowoop*",
231 "*metadata*",
232 "*narrowklass*",
233 "*conflict*"
234 };
235 const char* type2name(BasicType t) {
236 if (t < ARRAY_SIZE(type2name_tab)) {
237 return type2name_tab[t];
238 } else if (t == T_ILLEGAL) {
239 return "*illegal*";
240 } else {
241 fatal("invalid type %d", t);
242 return "invalid type";
243 }
244 }
245
246
247
248 BasicType name2type(const char* name) {
249 for (int i = T_BOOLEAN; i <= T_VOID; i++) {
250 BasicType t = (BasicType)i;
251 if (type2name_tab[t] != nullptr && 0 == strcmp(type2name_tab[t], name))
252 return t;
253 }
254 return T_ILLEGAL;
255 }
256
257 // Map BasicType to size in words
258 int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, -1};
259
260 BasicType type2field[T_CONFLICT+1] = {
261 (BasicType)0, // 0,
262 (BasicType)0, // 1,
263 (BasicType)0, // 2,
264 (BasicType)0, // 3,
265 T_BOOLEAN, // T_BOOLEAN = 4,
266 T_CHAR, // T_CHAR = 5,
267 T_FLOAT, // T_FLOAT = 6,
268 T_DOUBLE, // T_DOUBLE = 7,
269 T_BYTE, // T_BYTE = 8,
270 T_SHORT, // T_SHORT = 9,
271 T_INT, // T_INT = 10,
272 T_LONG, // T_LONG = 11,
273 T_OBJECT, // T_OBJECT = 12,
274 T_OBJECT, // T_ARRAY = 13,
275 T_VOID, // T_VOID = 14,
276 T_ADDRESS, // T_ADDRESS = 15,
277 T_NARROWOOP, // T_NARROWOOP= 16,
278 T_METADATA, // T_METADATA = 17,
279 T_NARROWKLASS, // T_NARROWKLASS = 18,
280 T_CONFLICT // T_CONFLICT = 19,
281 };
282
283
284 BasicType type2wfield[T_CONFLICT+1] = {
285 (BasicType)0, // 0,
286 (BasicType)0, // 1,
287 (BasicType)0, // 2,
288 (BasicType)0, // 3,
289 T_INT, // T_BOOLEAN = 4,
290 T_INT, // T_CHAR = 5,
291 T_FLOAT, // T_FLOAT = 6,
292 T_DOUBLE, // T_DOUBLE = 7,
293 T_INT, // T_BYTE = 8,
294 T_INT, // T_SHORT = 9,
295 T_INT, // T_INT = 10,
296 T_LONG, // T_LONG = 11,
297 T_OBJECT, // T_OBJECT = 12,
298 T_OBJECT, // T_ARRAY = 13,
299 T_VOID, // T_VOID = 14,
300 T_ADDRESS, // T_ADDRESS = 15,
301 T_NARROWOOP, // T_NARROWOOP = 16,
302 T_METADATA, // T_METADATA = 17,
303 T_NARROWKLASS, // T_NARROWKLASS = 18,
304 T_CONFLICT // T_CONFLICT = 19,
305 };
306
307
308 int _type2aelembytes[T_CONFLICT+1] = {
309 0, // 0
310 0, // 1
311 0, // 2
312 0, // 3
313 T_BOOLEAN_aelem_bytes, // T_BOOLEAN = 4,
314 T_CHAR_aelem_bytes, // T_CHAR = 5,
315 T_FLOAT_aelem_bytes, // T_FLOAT = 6,
316 T_DOUBLE_aelem_bytes, // T_DOUBLE = 7,
317 T_BYTE_aelem_bytes, // T_BYTE = 8,
318 T_SHORT_aelem_bytes, // T_SHORT = 9,
319 T_INT_aelem_bytes, // T_INT = 10,
320 T_LONG_aelem_bytes, // T_LONG = 11,
321 T_OBJECT_aelem_bytes, // T_OBJECT = 12,
322 T_ARRAY_aelem_bytes, // T_ARRAY = 13,
323 0, // T_VOID = 14,
324 T_OBJECT_aelem_bytes, // T_ADDRESS = 15,
325 T_NARROWOOP_aelem_bytes, // T_NARROWOOP= 16,
326 T_OBJECT_aelem_bytes, // T_METADATA = 17,
327 T_NARROWKLASS_aelem_bytes, // T_NARROWKLASS= 18,
328 0 // T_CONFLICT = 19,
329 };
330
331 #ifdef ASSERT
332 int type2aelembytes(BasicType t, bool allow_address) {
333 assert((allow_address || t != T_ADDRESS) && t <= T_CONFLICT, "unexpected basic type");
334 return _type2aelembytes[t];
335 }
336 #endif
337
338 // Support for 64-bit integer arithmetic
339
340 // The following code is mostly taken from JVM typedefs_md.h and system_md.c
341
342 static const jlong high_bit = (jlong)1 << (jlong)63;
343 static const jlong other_bits = ~high_bit;
344
345 jlong float2long(jfloat f) {
346 jlong tmp = (jlong) f;
347 if (tmp != high_bit) {
348 return tmp;
|
191 } else {
192 heapOopSize = oopSize;
193 LogBytesPerHeapOop = LogBytesPerWord;
194 LogBitsPerHeapOop = LogBitsPerWord;
195 BytesPerHeapOop = BytesPerWord;
196 BitsPerHeapOop = BitsPerWord;
197 }
198 _type2aelembytes[T_OBJECT] = heapOopSize;
199 _type2aelembytes[T_ARRAY] = heapOopSize;
200 }
201
202
203 // Map BasicType to signature character
204 char type2char_tab[T_CONFLICT+1] = {
205 0, 0, 0, 0,
206 JVM_SIGNATURE_BOOLEAN, JVM_SIGNATURE_CHAR,
207 JVM_SIGNATURE_FLOAT, JVM_SIGNATURE_DOUBLE,
208 JVM_SIGNATURE_BYTE, JVM_SIGNATURE_SHORT,
209 JVM_SIGNATURE_INT, JVM_SIGNATURE_LONG,
210 JVM_SIGNATURE_CLASS, JVM_SIGNATURE_ARRAY,
211 JVM_SIGNATURE_VOID,
212 0, 0, 0, 0, 0, 0
213 };
214
215 // Map BasicType to Java type name
216 const char* type2name_tab[T_CONFLICT+1] = {
217 nullptr, nullptr, nullptr, nullptr,
218 "boolean",
219 "char",
220 "float",
221 "double",
222 "byte",
223 "short",
224 "int",
225 "long",
226 "object",
227 "array",
228 "void",
229 "flat element",
230 "*address*",
231 "*narrowoop*",
232 "*metadata*",
233 "*narrowklass*",
234 "*conflict*"
235 };
236 const char* type2name(BasicType t) {
237 if (t < ARRAY_SIZE(type2name_tab)) {
238 return type2name_tab[t];
239 } else if (t == T_ILLEGAL) {
240 return "*illegal*";
241 } else {
242 fatal("invalid type %d", t);
243 return "invalid type";
244 }
245 }
246
247
248
249 BasicType name2type(const char* name) {
250 for (int i = T_BOOLEAN; i <= T_VOID; i++) {
251 BasicType t = (BasicType)i;
252 if (type2name_tab[t] != nullptr && 0 == strcmp(type2name_tab[t], name))
253 return t;
254 }
255 return T_ILLEGAL;
256 }
257
258 // Map BasicType to size in words
259 int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, -1, 1, 1, 1, 1, -1};
260
261 BasicType type2field[T_CONFLICT+1] = {
262 (BasicType)0, // 0,
263 (BasicType)0, // 1,
264 (BasicType)0, // 2,
265 (BasicType)0, // 3,
266 T_BOOLEAN, // T_BOOLEAN = 4,
267 T_CHAR, // T_CHAR = 5,
268 T_FLOAT, // T_FLOAT = 6,
269 T_DOUBLE, // T_DOUBLE = 7,
270 T_BYTE, // T_BYTE = 8,
271 T_SHORT, // T_SHORT = 9,
272 T_INT, // T_INT = 10,
273 T_LONG, // T_LONG = 11,
274 T_OBJECT, // T_OBJECT = 12,
275 T_OBJECT, // T_ARRAY = 13,
276 T_VOID, // T_VOID = 14,
277 (BasicType)0, // T_FLAT_ELEMENT = 15,
278 T_ADDRESS, // T_ADDRESS = 16,
279 T_NARROWOOP, // T_NARROWOOP= 17,
280 T_METADATA, // T_METADATA = 18,
281 T_NARROWKLASS, // T_NARROWKLASS = 19,
282 T_CONFLICT // T_CONFLICT = 20
283 };
284
285
286 BasicType type2wfield[T_CONFLICT+1] = {
287 (BasicType)0, // 0,
288 (BasicType)0, // 1,
289 (BasicType)0, // 2,
290 (BasicType)0, // 3,
291 T_INT, // T_BOOLEAN = 4,
292 T_INT, // T_CHAR = 5,
293 T_FLOAT, // T_FLOAT = 6,
294 T_DOUBLE, // T_DOUBLE = 7,
295 T_INT, // T_BYTE = 8,
296 T_INT, // T_SHORT = 9,
297 T_INT, // T_INT = 10,
298 T_LONG, // T_LONG = 11,
299 T_OBJECT, // T_OBJECT = 12,
300 T_OBJECT, // T_ARRAY = 13,
301 T_VOID, // T_VOID = 14,
302 (BasicType)0, // T_FLAT_ELEMENT = 15,
303 T_ADDRESS, // T_ADDRESS = 16,
304 T_NARROWOOP, // T_NARROWOOP = 17,
305 T_METADATA, // T_METADATA = 18,
306 T_NARROWKLASS, // T_NARROWKLASS = 19,
307 T_CONFLICT // T_CONFLICT = 20
308 };
309
310
311 int _type2aelembytes[T_CONFLICT+1] = {
312 0, // 0
313 0, // 1
314 0, // 2
315 0, // 3
316 T_BOOLEAN_aelem_bytes, // T_BOOLEAN = 4,
317 T_CHAR_aelem_bytes, // T_CHAR = 5,
318 T_FLOAT_aelem_bytes, // T_FLOAT = 6,
319 T_DOUBLE_aelem_bytes, // T_DOUBLE = 7,
320 T_BYTE_aelem_bytes, // T_BYTE = 8,
321 T_SHORT_aelem_bytes, // T_SHORT = 9,
322 T_INT_aelem_bytes, // T_INT = 10,
323 T_LONG_aelem_bytes, // T_LONG = 11,
324 T_OBJECT_aelem_bytes, // T_OBJECT = 12,
325 T_ARRAY_aelem_bytes, // T_ARRAY = 13,
326 0, // T_VOID = 14,
327 0, // T_FLAT_ELEMENT = 15,
328 T_OBJECT_aelem_bytes, // T_ADDRESS = 16,
329 T_NARROWOOP_aelem_bytes, // T_NARROWOOP= 17,
330 T_OBJECT_aelem_bytes, // T_METADATA = 18,
331 T_NARROWKLASS_aelem_bytes, // T_NARROWKLASS= 19,
332 0 // T_CONFLICT = 20
333 };
334
335 #ifdef ASSERT
336 int type2aelembytes(BasicType t, bool allow_address) {
337 assert((allow_address || t != T_ADDRESS) && t <= T_CONFLICT, "unexpected basic type");
338 return _type2aelembytes[t];
339 }
340 #endif
341
342 // Support for 64-bit integer arithmetic
343
344 // The following code is mostly taken from JVM typedefs_md.h and system_md.c
345
346 static const jlong high_bit = (jlong)1 << (jlong)63;
347 static const jlong other_bits = ~high_bit;
348
349 jlong float2long(jfloat f) {
350 jlong tmp = (jlong) f;
351 if (tmp != high_bit) {
352 return tmp;
|