< prev index next >

src/hotspot/share/utilities/globalDefinitions.cpp

Print this page

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;
< prev index next >