53 static const char* vm_symbol_enum_name(vmSymbols::SID sid) {
54 const char* string = &vm_symbol_enum_names[0];
55 int skip = (int)sid - (int)vmSymbols::FIRST_SID;
56 for (; skip != 0; skip--) {
57 size_t skiplen = strlen(string);
58 if (skiplen == 0) return "<unknown>"; // overflow
59 string += skiplen+1;
60 }
61 return string;
62 }
63 #endif //PRODUCT
64
65 // Put all the VM symbol strings in one place.
66 // Makes for a more compact libjvm.
67 #define VM_SYMBOL_BODY(name, string) string "\0"
68 static const char* vm_symbol_bodies = VM_SYMBOLS_DO(VM_SYMBOL_BODY, VM_ALIAS_IGNORE);
69
70 void vmSymbols::initialize(TRAPS) {
71 assert((int)SID_LIMIT <= (1<<log2_SID_LIMIT), "must fit in this bitfield");
72 assert((int)SID_LIMIT*5 > (1<<log2_SID_LIMIT), "make the bitfield smaller, please");
73
74 if (!UseSharedSpaces) {
75 const char* string = &vm_symbol_bodies[0];
76 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
77 symbolOop sym = oopFactory::new_symbol(string, CHECK);
78 _symbols[index] = sym;
79 string += strlen(string); // skip string body
80 string += 1; // skip trailing null
81 }
82
83 _type_signatures[T_BYTE] = byte_signature();
84 _type_signatures[T_CHAR] = char_signature();
85 _type_signatures[T_DOUBLE] = double_signature();
86 _type_signatures[T_FLOAT] = float_signature();
87 _type_signatures[T_INT] = int_signature();
88 _type_signatures[T_LONG] = long_signature();
89 _type_signatures[T_SHORT] = short_signature();
90 _type_signatures[T_BOOLEAN] = bool_signature();
91 _type_signatures[T_VOID] = void_signature();
92 // no single signatures for T_OBJECT or T_ARRAY
254 // Make sure this is the right answer, using linear search.
255 // (We have already proven that there are no duplicates in the list.)
256 SID sid2 = NO_SID;
257 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
258 symbolOop sym2 = symbol_at((SID)index);
259 if (sym2 == symbol) {
260 sid2 = (SID)index;
261 break;
262 }
263 }
264 // Unless it's a duplicate, assert that the sids are the same.
265 if (_symbols[sid] != _symbols[sid2]) {
266 assert(sid == sid2, "binary same as linear search");
267 }
268 }
269 #endif //ASSERT
270
271 return sid;
272 }
273
274
275 #define VM_INTRINSIC_INITIALIZE(id, klass, name, sig, flags) #id "\0"
276 static const char* vm_intrinsic_name_bodies =
277 VM_INTRINSICS_DO(VM_INTRINSIC_INITIALIZE,
278 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
279
280 static const char* vm_intrinsic_name_table[vmIntrinsics::ID_LIMIT];
281
282 const char* vmIntrinsics::name_at(vmIntrinsics::ID id) {
283 const char** nt = &vm_intrinsic_name_table[0];
284 if (nt[_none] == NULL) {
285 char* string = (char*) &vm_intrinsic_name_bodies[0];
286 for (int index = FIRST_ID; index < ID_LIMIT; index++) {
287 nt[index] = string;
288 string += strlen(string); // skip string body
289 string += 1; // skip trailing null
290 }
291 assert(!strcmp(nt[_hashCode], "_hashCode"), "lined up");
292 nt[_none] = "_none";
293 }
360 const char* mname = vmSymbols::name_for(name_for(id));
361 const char* sname = vmSymbols::name_for(signature_for(id));
362 const char* fname = "";
363 switch (flags_for(id)) {
364 case F_RN: fname = "native "; break;
365 case F_SN: fname = "native static "; break;
366 case F_S: fname = "static "; break;
367 case F_RNY:fname = "native synchronized "; break;
368 }
369 const char* kptr = strrchr(kname, '/');
370 if (kptr != NULL) kname = kptr + 1;
371 int len = jio_snprintf(buf, buflen, "%s: %s%s.%s%s",
372 str, fname, kname, mname, sname);
373 if (len < buflen)
374 str = buf;
375 #endif //PRODUCT
376 return str;
377 }
378
379
380 // These are for friendly printouts of intrinsics:
381
382 vmSymbols::SID vmIntrinsics::class_for(vmIntrinsics::ID id) {
383 #ifndef PRODUCT
384 #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
385 case id: return SID_ENUM(klass);
386
387 switch (id) {
388 VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
389 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
390 }
391 #undef VM_INTRINSIC_CASE
392 #endif //PRODUCT
393 return vmSymbols::NO_SID;
394 }
395
396 vmSymbols::SID vmIntrinsics::name_for(vmIntrinsics::ID id) {
397 #ifndef PRODUCT
398 #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
399 case id: return SID_ENUM(name);
400
401 switch (id) {
402 VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
403 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
404 }
405 #undef VM_INTRINSIC_CASE
406 #endif //PRODUCT
407 return vmSymbols::NO_SID;
408 }
409
410 vmSymbols::SID vmIntrinsics::signature_for(vmIntrinsics::ID id) {
411 #ifndef PRODUCT
412 #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
413 case id: return SID_ENUM(sig);
414
415 switch (id) {
416 VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
417 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
418 }
419 #undef VM_INTRINSIC_CASE
420 #endif //PRODUCT
421 return vmSymbols::NO_SID;
422 }
423
424 vmIntrinsics::Flags vmIntrinsics::flags_for(vmIntrinsics::ID id) {
425 #ifndef PRODUCT
426 #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
427 case id: return fcode;
428
429 switch (id) {
430 VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
431 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
432 }
433 #undef VM_INTRINSIC_CASE
434 #endif //PRODUCT
435 return F_none;
436 }
437
438
439 #ifndef PRODUCT
440 // verify_method performs an extra check on a matched intrinsic method
441
442 static bool match_method(methodOop m, symbolOop n, symbolOop s) {
443 return (m->name() == n &&
444 m->signature() == s);
445 }
446
447 static vmIntrinsics::ID match_method_with_klass(methodOop m, symbolOop mk) {
448 #define VM_INTRINSIC_MATCH(id, klassname, namepart, sigpart, flags) \
449 { symbolOop k = vmSymbols::klassname(); \
450 if (mk == k) { \
451 symbolOop n = vmSymbols::namepart(); \
452 symbolOop s = vmSymbols::sigpart(); \
453 if (match_method(m, n, s)) \
454 return vmIntrinsics::id; \
455 } }
|
53 static const char* vm_symbol_enum_name(vmSymbols::SID sid) {
54 const char* string = &vm_symbol_enum_names[0];
55 int skip = (int)sid - (int)vmSymbols::FIRST_SID;
56 for (; skip != 0; skip--) {
57 size_t skiplen = strlen(string);
58 if (skiplen == 0) return "<unknown>"; // overflow
59 string += skiplen+1;
60 }
61 return string;
62 }
63 #endif //PRODUCT
64
65 // Put all the VM symbol strings in one place.
66 // Makes for a more compact libjvm.
67 #define VM_SYMBOL_BODY(name, string) string "\0"
68 static const char* vm_symbol_bodies = VM_SYMBOLS_DO(VM_SYMBOL_BODY, VM_ALIAS_IGNORE);
69
70 void vmSymbols::initialize(TRAPS) {
71 assert((int)SID_LIMIT <= (1<<log2_SID_LIMIT), "must fit in this bitfield");
72 assert((int)SID_LIMIT*5 > (1<<log2_SID_LIMIT), "make the bitfield smaller, please");
73 assert(vmIntrinsics::FLAG_LIMIT <= (1 << vmIntrinsics::log2_FLAG_LIMIT), "must fit in this bitfield");
74
75 if (!UseSharedSpaces) {
76 const char* string = &vm_symbol_bodies[0];
77 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
78 symbolOop sym = oopFactory::new_symbol(string, CHECK);
79 _symbols[index] = sym;
80 string += strlen(string); // skip string body
81 string += 1; // skip trailing null
82 }
83
84 _type_signatures[T_BYTE] = byte_signature();
85 _type_signatures[T_CHAR] = char_signature();
86 _type_signatures[T_DOUBLE] = double_signature();
87 _type_signatures[T_FLOAT] = float_signature();
88 _type_signatures[T_INT] = int_signature();
89 _type_signatures[T_LONG] = long_signature();
90 _type_signatures[T_SHORT] = short_signature();
91 _type_signatures[T_BOOLEAN] = bool_signature();
92 _type_signatures[T_VOID] = void_signature();
93 // no single signatures for T_OBJECT or T_ARRAY
255 // Make sure this is the right answer, using linear search.
256 // (We have already proven that there are no duplicates in the list.)
257 SID sid2 = NO_SID;
258 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
259 symbolOop sym2 = symbol_at((SID)index);
260 if (sym2 == symbol) {
261 sid2 = (SID)index;
262 break;
263 }
264 }
265 // Unless it's a duplicate, assert that the sids are the same.
266 if (_symbols[sid] != _symbols[sid2]) {
267 assert(sid == sid2, "binary same as linear search");
268 }
269 }
270 #endif //ASSERT
271
272 return sid;
273 }
274
275 static vmIntrinsics::ID wrapper_intrinsic(BasicType type, bool unboxing) {
276 #define TYPE2(type, unboxing) ((int)(type)*2 + ((unboxing) ? 1 : 0))
277 switch (TYPE2(type, unboxing)) {
278 #define BASIC_TYPE_CASE(type, box, unbox) \
279 case TYPE2(type, false): return vmIntrinsics::box; \
280 case TYPE2(type, true): return vmIntrinsics::unbox
281 BASIC_TYPE_CASE(T_BOOLEAN, _Boolean_valueOf, _booleanValue);
282 BASIC_TYPE_CASE(T_BYTE, _Byte_valueOf, _byteValue);
283 BASIC_TYPE_CASE(T_CHAR, _Character_valueOf, _charValue);
284 BASIC_TYPE_CASE(T_SHORT, _Short_valueOf, _shortValue);
285 BASIC_TYPE_CASE(T_INT, _Integer_valueOf, _intValue);
286 BASIC_TYPE_CASE(T_LONG, _Long_valueOf, _longValue);
287 BASIC_TYPE_CASE(T_FLOAT, _Float_valueOf, _floatValue);
288 BASIC_TYPE_CASE(T_DOUBLE, _Double_valueOf, _doubleValue);
289 #undef BASIC_TYPE_CASE
290 }
291 #undef TYPE2
292 return vmIntrinsics::_none;
293 }
294
295 vmIntrinsics::ID vmIntrinsics::for_boxing(BasicType type) {
296 return wrapper_intrinsic(type, false);
297 }
298 vmIntrinsics::ID vmIntrinsics::for_unboxing(BasicType type) {
299 return wrapper_intrinsic(type, true);
300 }
301
302 methodOop vmIntrinsics::method_for(vmIntrinsics::ID id) {
303 if (id == _none) return NULL;
304 symbolOop cname = vmSymbols::symbol_at(class_for(id));
305 symbolOop mname = vmSymbols::symbol_at(name_for(id));
306 symbolOop msig = vmSymbols::symbol_at(signature_for(id));
307 if (cname == NULL || mname == NULL || msig == NULL) return NULL;
308 klassOop k = SystemDictionary::find_well_known_klass(cname);
309 if (k == NULL) return NULL;
310 return instanceKlass::cast(k)->find_method(mname, msig);
311 }
312
313
314 #define VM_INTRINSIC_INITIALIZE(id, klass, name, sig, flags) #id "\0"
315 static const char* vm_intrinsic_name_bodies =
316 VM_INTRINSICS_DO(VM_INTRINSIC_INITIALIZE,
317 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
318
319 static const char* vm_intrinsic_name_table[vmIntrinsics::ID_LIMIT];
320
321 const char* vmIntrinsics::name_at(vmIntrinsics::ID id) {
322 const char** nt = &vm_intrinsic_name_table[0];
323 if (nt[_none] == NULL) {
324 char* string = (char*) &vm_intrinsic_name_bodies[0];
325 for (int index = FIRST_ID; index < ID_LIMIT; index++) {
326 nt[index] = string;
327 string += strlen(string); // skip string body
328 string += 1; // skip trailing null
329 }
330 assert(!strcmp(nt[_hashCode], "_hashCode"), "lined up");
331 nt[_none] = "_none";
332 }
399 const char* mname = vmSymbols::name_for(name_for(id));
400 const char* sname = vmSymbols::name_for(signature_for(id));
401 const char* fname = "";
402 switch (flags_for(id)) {
403 case F_RN: fname = "native "; break;
404 case F_SN: fname = "native static "; break;
405 case F_S: fname = "static "; break;
406 case F_RNY:fname = "native synchronized "; break;
407 }
408 const char* kptr = strrchr(kname, '/');
409 if (kptr != NULL) kname = kptr + 1;
410 int len = jio_snprintf(buf, buflen, "%s: %s%s.%s%s",
411 str, fname, kname, mname, sname);
412 if (len < buflen)
413 str = buf;
414 #endif //PRODUCT
415 return str;
416 }
417
418
419 // These are to get information about intrinsics.
420
421 #define ID4(x, y, z, f) ((ID3(x, y, z) << vmIntrinsics::log2_FLAG_LIMIT) | (int)(f))
422
423 static const jint intrinsic_info_array[vmIntrinsics::ID_LIMIT+1] = {
424 #define VM_INTRINSIC_INFO(ignore_id, klass, name, sig, fcode) \
425 ID4(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig), vmIntrinsics::fcode),
426
427 0, VM_INTRINSICS_DO(VM_INTRINSIC_INFO,
428 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE)
429 0
430 #undef VM_INTRINSIC_INFO
431 };
432
433 inline jint intrinsic_info(vmIntrinsics::ID id) {
434 return intrinsic_info_array[vmIntrinsics::ID_from((int)id)];
435 }
436
437 vmSymbols::SID vmIntrinsics::class_for(vmIntrinsics::ID id) {
438 jint info = intrinsic_info(id);
439 int shift = 2*vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
440 assert(((ID4(31,1022,1023,15) >> shift) & mask) == 31, "");
441 return vmSymbols::SID( (info >> shift) & mask );
442 }
443
444 vmSymbols::SID vmIntrinsics::name_for(vmIntrinsics::ID id) {
445 jint info = intrinsic_info(id);
446 int shift = vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
447 assert(((ID4(31,1022,1023,15) >> shift) & mask) == 1022, "");
448 return vmSymbols::SID( (info >> shift) & mask );
449 }
450
451 vmSymbols::SID vmIntrinsics::signature_for(vmIntrinsics::ID id) {
452 jint info = intrinsic_info(id);
453 int shift = log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
454 assert(((ID4(31,1022,1023,15) >> shift) & mask) == 1023, "");
455 return vmSymbols::SID( (info >> shift) & mask );
456 }
457
458 vmIntrinsics::Flags vmIntrinsics::flags_for(vmIntrinsics::ID id) {
459 jint info = intrinsic_info(id);
460 int shift = 0, mask = right_n_bits(log2_FLAG_LIMIT);
461 assert(((ID4(31,1022,1023,15) >> shift) & mask) == 15, "");
462 return Flags( (info >> shift) & mask );
463 }
464
465
466 #ifndef PRODUCT
467 // verify_method performs an extra check on a matched intrinsic method
468
469 static bool match_method(methodOop m, symbolOop n, symbolOop s) {
470 return (m->name() == n &&
471 m->signature() == s);
472 }
473
474 static vmIntrinsics::ID match_method_with_klass(methodOop m, symbolOop mk) {
475 #define VM_INTRINSIC_MATCH(id, klassname, namepart, sigpart, flags) \
476 { symbolOop k = vmSymbols::klassname(); \
477 if (mk == k) { \
478 symbolOop n = vmSymbols::namepart(); \
479 symbolOop s = vmSymbols::sigpart(); \
480 if (match_method(m, n, s)) \
481 return vmIntrinsics::id; \
482 } }
|