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