src/share/vm/classfile/vmSymbols.cpp

rev 1072 : [mq]: meth.walker.patch

*** 68,77 ****
--- 68,78 ----
  static const char* vm_symbol_bodies = VM_SYMBOLS_DO(VM_SYMBOL_BODY, VM_ALIAS_IGNORE);
  
  void vmSymbols::initialize(TRAPS) {
    assert((int)SID_LIMIT <= (1<<log2_SID_LIMIT), "must fit in this bitfield");
    assert((int)SID_LIMIT*5 > (1<<log2_SID_LIMIT), "make the bitfield smaller, please");
+   assert(vmIntrinsics::FLAG_LIMIT <= (1 << vmIntrinsics::log2_FLAG_LIMIT), "must fit in this bitfield");
  
    if (!UseSharedSpaces) {
      const char* string = &vm_symbol_bodies[0];
      for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
        symbolOop sym = oopFactory::new_symbol(string, CHECK);
*** 269,278 ****
--- 270,317 ----
  #endif //ASSERT
  
    return sid;
  }
  
+ static vmIntrinsics::ID wrapper_intrinsic(BasicType type, bool unboxing) {
+ #define TYPE2(type, unboxing) ((int)(type)*2 + ((unboxing) ? 1 : 0))
+   switch (TYPE2(type, unboxing)) {
+ #define BASIC_TYPE_CASE(type, box, unbox) \
+     case TYPE2(type, false):  return vmIntrinsics::box; \
+     case TYPE2(type, true):   return vmIntrinsics::unbox
+     BASIC_TYPE_CASE(T_BOOLEAN, _Boolean_valueOf,   _booleanValue);
+     BASIC_TYPE_CASE(T_BYTE,    _Byte_valueOf,      _byteValue);
+     BASIC_TYPE_CASE(T_CHAR,    _Character_valueOf, _charValue);
+     BASIC_TYPE_CASE(T_SHORT,   _Short_valueOf,     _shortValue);
+     BASIC_TYPE_CASE(T_INT,     _Integer_valueOf,   _intValue);
+     BASIC_TYPE_CASE(T_LONG,    _Long_valueOf,      _longValue);
+     BASIC_TYPE_CASE(T_FLOAT,   _Float_valueOf,     _floatValue);
+     BASIC_TYPE_CASE(T_DOUBLE,  _Double_valueOf,    _doubleValue);
+ #undef BASIC_TYPE_CASE
+   }
+ #undef TYPE2
+   return vmIntrinsics::_none;
+ }
+ 
+ vmIntrinsics::ID vmIntrinsics::for_boxing(BasicType type) {
+   return wrapper_intrinsic(type, false);
+ }
+ vmIntrinsics::ID vmIntrinsics::for_unboxing(BasicType type) {
+   return wrapper_intrinsic(type, true);
+ }
+ 
+ methodOop vmIntrinsics::method_for(vmIntrinsics::ID id) {
+   if (id == _none)  return NULL;
+   symbolOop cname = vmSymbols::symbol_at(class_for(id));
+   symbolOop mname = vmSymbols::symbol_at(name_for(id));
+   symbolOop msig  = vmSymbols::symbol_at(signature_for(id));
+   if (cname == NULL || mname == NULL || msig == NULL)  return NULL;
+   klassOop k = SystemDictionary::find_well_known_klass(cname);
+   if (k == NULL)  return NULL;
+   return instanceKlass::cast(k)->find_method(mname, msig);
+ }
+ 
  
  #define VM_INTRINSIC_INITIALIZE(id, klass, name, sig, flags) #id "\0"
  static const char* vm_intrinsic_name_bodies =
    VM_INTRINSICS_DO(VM_INTRINSIC_INITIALIZE,
                     VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
*** 375,440 ****
  #endif //PRODUCT
    return str;
  }
  
  
! // These are for friendly printouts of intrinsics:
  
! vmSymbols::SID vmIntrinsics::class_for(vmIntrinsics::ID id) {
! #ifndef PRODUCT
! #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
!   case id: return SID_ENUM(klass);
  
!   switch (id) {
!     VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
!                      VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
!   }
! #undef VM_INTRINSIC_CASE
! #endif //PRODUCT
!   return vmSymbols::NO_SID;
  }
  
! vmSymbols::SID vmIntrinsics::name_for(vmIntrinsics::ID id) {
! #ifndef PRODUCT
! #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
!   case id: return SID_ENUM(name);
  
!   switch (id) {
!     VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
!                      VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
!   }
! #undef VM_INTRINSIC_CASE
! #endif //PRODUCT
!   return vmSymbols::NO_SID;
  }
  
  vmSymbols::SID vmIntrinsics::signature_for(vmIntrinsics::ID id) {
! #ifndef PRODUCT
! #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
!   case id: return SID_ENUM(sig);
! 
!   switch (id) {
!     VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
!                      VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
!   }
! #undef VM_INTRINSIC_CASE
! #endif //PRODUCT
!   return vmSymbols::NO_SID;
  }
  
  vmIntrinsics::Flags vmIntrinsics::flags_for(vmIntrinsics::ID id) {
! #ifndef PRODUCT
! #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
!   case id: return fcode;
! 
!   switch (id) {
!     VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
!                      VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
!   }
! #undef VM_INTRINSIC_CASE
! #endif //PRODUCT
!   return F_none;
  }
  
  
  #ifndef PRODUCT
  // verify_method performs an extra check on a matched intrinsic method
--- 414,467 ----
  #endif //PRODUCT
    return str;
  }
  
  
! // These are to get information about intrinsics.
  
! #define ID4(x, y, z, f) ((ID3(x, y, z) << vmIntrinsics::log2_FLAG_LIMIT) | (int)(f))
  
! static const jint intrinsic_info_array[vmIntrinsics::ID_LIMIT+1] = {
! #define VM_INTRINSIC_INFO(ignore_id, klass, name, sig, fcode) \
!   ID4(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig), vmIntrinsics::fcode),
! 
!   0, VM_INTRINSICS_DO(VM_INTRINSIC_INFO,
!                      VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE)
!     0
! #undef VM_INTRINSIC_INFO
! };
! 
! inline jint intrinsic_info(vmIntrinsics::ID id) {
!   return intrinsic_info_array[vmIntrinsics::ID_from((int)id)];
  }
  
! vmSymbols::SID vmIntrinsics::class_for(vmIntrinsics::ID id) {
!   jint info = intrinsic_info(id);
!   int shift = 2*vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
!   assert(((ID4(31,1022,1023,15) >> shift) & mask) == 31, "");
!   return vmSymbols::SID( (info >> shift) & mask );
! }
  
! vmSymbols::SID vmIntrinsics::name_for(vmIntrinsics::ID id) {
!   jint info = intrinsic_info(id);
!   int shift = vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
!   assert(((ID4(31,1022,1023,15) >> shift) & mask) == 1022, "");
!   return vmSymbols::SID( (info >> shift) & mask );
  }
  
  vmSymbols::SID vmIntrinsics::signature_for(vmIntrinsics::ID id) {
!   jint info = intrinsic_info(id);
!   int shift = log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
!   assert(((ID4(31,1022,1023,15) >> shift) & mask) == 1023, "");
!   return vmSymbols::SID( (info >> shift) & mask );
  }
  
  vmIntrinsics::Flags vmIntrinsics::flags_for(vmIntrinsics::ID id) {
!   jint info = intrinsic_info(id);
!   int shift = 0, mask = right_n_bits(log2_FLAG_LIMIT);
!   assert(((ID4(31,1022,1023,15) >> shift) & mask) == 15, "");
!   return Flags( (info >> shift) & mask );
  }
  
  
  #ifndef PRODUCT
  // verify_method performs an extra check on a matched intrinsic method