src/hotspot/share/classfile/javaClasses.cpp
changeset 55159 a38132298eda
parent 54847 59ea39bb2809
child 55251 92eec0732eed
equal deleted inserted replaced
55158:d3e404cc3972 55159:a38132298eda
  4153 int java_lang_AssertionStatusDirectives::deflt_offset;
  4153 int java_lang_AssertionStatusDirectives::deflt_offset;
  4154 int java_nio_Buffer::_limit_offset;
  4154 int java_nio_Buffer::_limit_offset;
  4155 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset;
  4155 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset;
  4156 int reflect_ConstantPool::_oop_offset;
  4156 int reflect_ConstantPool::_oop_offset;
  4157 int reflect_UnsafeStaticFieldAccessorImpl::_base_offset;
  4157 int reflect_UnsafeStaticFieldAccessorImpl::_base_offset;
       
  4158 int java_lang_Integer_IntegerCache::_static_cache_offset;
       
  4159 int java_lang_Long_LongCache::_static_cache_offset;
       
  4160 int java_lang_Character_CharacterCache::_static_cache_offset;
       
  4161 int java_lang_Short_ShortCache::_static_cache_offset;
       
  4162 int java_lang_Byte_ByteCache::_static_cache_offset;
       
  4163 int java_lang_Boolean::_static_TRUE_offset;
       
  4164 int java_lang_Boolean::_static_FALSE_offset;
       
  4165 
  4158 
  4166 
  4159 
  4167 
  4160 #define STACKTRACEELEMENT_FIELDS_DO(macro) \
  4168 #define STACKTRACEELEMENT_FIELDS_DO(macro) \
  4161   macro(declaringClassObject_offset,  k, "declaringClassObject", class_signature, false); \
  4169   macro(declaringClassObject_offset,  k, "declaringClassObject", class_signature, false); \
  4162   macro(classLoaderName_offset, k, "classLoaderName", string_signature, false); \
  4170   macro(classLoaderName_offset, k, "classLoaderName", string_signature, false); \
  4311 #if INCLUDE_CDS
  4319 #if INCLUDE_CDS
  4312 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize_offsets(SerializeClosure* f) {
  4320 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize_offsets(SerializeClosure* f) {
  4313   AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
  4321   AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
  4314 }
  4322 }
  4315 #endif
  4323 #endif
       
  4324 
       
  4325 #define INTEGER_CACHE_FIELDS_DO(macro) \
       
  4326   macro(_static_cache_offset, k, "cache", java_lang_Integer_array_signature, true)
       
  4327 
       
  4328 void java_lang_Integer_IntegerCache::compute_offsets(InstanceKlass *k) {
       
  4329   guarantee(k != NULL && k->is_initialized(), "must be loaded and initialized");
       
  4330   INTEGER_CACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
       
  4331 }
       
  4332 
       
  4333 objArrayOop java_lang_Integer_IntegerCache::cache(InstanceKlass *ik) {
       
  4334   oop base = ik->static_field_base_raw();
       
  4335   return objArrayOop(base->obj_field(_static_cache_offset));
       
  4336 }
       
  4337 
       
  4338 Symbol* java_lang_Integer_IntegerCache::symbol() {
       
  4339   return vmSymbols::java_lang_Integer_IntegerCache();
       
  4340 }
       
  4341 
       
  4342 #if INCLUDE_CDS
       
  4343 void java_lang_Integer_IntegerCache::serialize_offsets(SerializeClosure* f) {
       
  4344   INTEGER_CACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
       
  4345 }
       
  4346 #endif
       
  4347 #undef INTEGER_CACHE_FIELDS_DO
       
  4348 
       
  4349 jint java_lang_Integer::value(oop obj) {
       
  4350    jvalue v;
       
  4351    java_lang_boxing_object::get_value(obj, &v);
       
  4352    return v.i;
       
  4353 }
       
  4354 
       
  4355 #define LONG_CACHE_FIELDS_DO(macro) \
       
  4356   macro(_static_cache_offset, k, "cache", java_lang_Long_array_signature, true)
       
  4357 
       
  4358 void java_lang_Long_LongCache::compute_offsets(InstanceKlass *k) {
       
  4359   guarantee(k != NULL && k->is_initialized(), "must be loaded and initialized");
       
  4360   LONG_CACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
       
  4361 }
       
  4362 
       
  4363 objArrayOop java_lang_Long_LongCache::cache(InstanceKlass *ik) {
       
  4364   oop base = ik->static_field_base_raw();
       
  4365   return objArrayOop(base->obj_field(_static_cache_offset));
       
  4366 }
       
  4367 
       
  4368 Symbol* java_lang_Long_LongCache::symbol() {
       
  4369   return vmSymbols::java_lang_Long_LongCache();
       
  4370 }
       
  4371 
       
  4372 #if INCLUDE_CDS
       
  4373 void java_lang_Long_LongCache::serialize_offsets(SerializeClosure* f) {
       
  4374   LONG_CACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
       
  4375 }
       
  4376 #endif
       
  4377 #undef LONG_CACHE_FIELDS_DO
       
  4378 
       
  4379 jlong java_lang_Long::value(oop obj) {
       
  4380    jvalue v;
       
  4381    java_lang_boxing_object::get_value(obj, &v);
       
  4382    return v.j;
       
  4383 }
       
  4384 
       
  4385 #define CHARACTER_CACHE_FIELDS_DO(macro) \
       
  4386   macro(_static_cache_offset, k, "cache", java_lang_Character_array_signature, true)
       
  4387 
       
  4388 void java_lang_Character_CharacterCache::compute_offsets(InstanceKlass *k) {
       
  4389   guarantee(k != NULL && k->is_initialized(), "must be loaded and initialized");
       
  4390   CHARACTER_CACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
       
  4391 }
       
  4392 
       
  4393 objArrayOop java_lang_Character_CharacterCache::cache(InstanceKlass *ik) {
       
  4394   oop base = ik->static_field_base_raw();
       
  4395   return objArrayOop(base->obj_field(_static_cache_offset));
       
  4396 }
       
  4397 
       
  4398 Symbol* java_lang_Character_CharacterCache::symbol() {
       
  4399   return vmSymbols::java_lang_Character_CharacterCache();
       
  4400 }
       
  4401 
       
  4402 #if INCLUDE_CDS
       
  4403 void java_lang_Character_CharacterCache::serialize_offsets(SerializeClosure* f) {
       
  4404   CHARACTER_CACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
       
  4405 }
       
  4406 #endif
       
  4407 #undef CHARACTER_CACHE_FIELDS_DO
       
  4408 
       
  4409 jchar java_lang_Character::value(oop obj) {
       
  4410    jvalue v;
       
  4411    java_lang_boxing_object::get_value(obj, &v);
       
  4412    return v.c;
       
  4413 }
       
  4414 
       
  4415 #define SHORT_CACHE_FIELDS_DO(macro) \
       
  4416   macro(_static_cache_offset, k, "cache", java_lang_Short_array_signature, true)
       
  4417 
       
  4418 void java_lang_Short_ShortCache::compute_offsets(InstanceKlass *k) {
       
  4419   guarantee(k != NULL && k->is_initialized(), "must be loaded and initialized");
       
  4420   SHORT_CACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
       
  4421 }
       
  4422 
       
  4423 objArrayOop java_lang_Short_ShortCache::cache(InstanceKlass *ik) {
       
  4424   oop base = ik->static_field_base_raw();
       
  4425   return objArrayOop(base->obj_field(_static_cache_offset));
       
  4426 }
       
  4427 
       
  4428 Symbol* java_lang_Short_ShortCache::symbol() {
       
  4429   return vmSymbols::java_lang_Short_ShortCache();
       
  4430 }
       
  4431 
       
  4432 #if INCLUDE_CDS
       
  4433 void java_lang_Short_ShortCache::serialize_offsets(SerializeClosure* f) {
       
  4434   SHORT_CACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
       
  4435 }
       
  4436 #endif
       
  4437 #undef SHORT_CACHE_FIELDS_DO
       
  4438 
       
  4439 jshort java_lang_Short::value(oop obj) {
       
  4440    jvalue v;
       
  4441    java_lang_boxing_object::get_value(obj, &v);
       
  4442    return v.s;
       
  4443 }
       
  4444 
       
  4445 #define BYTE_CACHE_FIELDS_DO(macro) \
       
  4446   macro(_static_cache_offset, k, "cache", java_lang_Byte_array_signature, true)
       
  4447 
       
  4448 void java_lang_Byte_ByteCache::compute_offsets(InstanceKlass *k) {
       
  4449   guarantee(k != NULL && k->is_initialized(), "must be loaded and initialized");
       
  4450   BYTE_CACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
       
  4451 }
       
  4452 
       
  4453 objArrayOop java_lang_Byte_ByteCache::cache(InstanceKlass *ik) {
       
  4454   oop base = ik->static_field_base_raw();
       
  4455   return objArrayOop(base->obj_field(_static_cache_offset));
       
  4456 }
       
  4457 
       
  4458 Symbol* java_lang_Byte_ByteCache::symbol() {
       
  4459   return vmSymbols::java_lang_Byte_ByteCache();
       
  4460 }
       
  4461 
       
  4462 #if INCLUDE_CDS
       
  4463 void java_lang_Byte_ByteCache::serialize_offsets(SerializeClosure* f) {
       
  4464   BYTE_CACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
       
  4465 }
       
  4466 #endif
       
  4467 #undef BYTE_CACHE_FIELDS_DO
       
  4468 
       
  4469 jbyte java_lang_Byte::value(oop obj) {
       
  4470    jvalue v;
       
  4471    java_lang_boxing_object::get_value(obj, &v);
       
  4472    return v.b;
       
  4473 }
       
  4474 #define BOOLEAN_FIELDS_DO(macro) \
       
  4475   macro(_static_TRUE_offset, k, "TRUE", java_lang_Boolean_signature, true); \
       
  4476   macro(_static_FALSE_offset, k, "FALSE", java_lang_Boolean_signature, true)
       
  4477 
       
  4478 
       
  4479 void java_lang_Boolean::compute_offsets(InstanceKlass *k) {
       
  4480   guarantee(k != NULL && k->is_initialized(), "must be loaded and initialized");
       
  4481   BOOLEAN_FIELDS_DO(FIELD_COMPUTE_OFFSET);
       
  4482 }
       
  4483 
       
  4484 oop java_lang_Boolean::get_TRUE(InstanceKlass *ik) {
       
  4485   oop base = ik->static_field_base_raw();
       
  4486   return base->obj_field(_static_TRUE_offset);
       
  4487 }
       
  4488 
       
  4489 oop java_lang_Boolean::get_FALSE(InstanceKlass *ik) {
       
  4490   oop base = ik->static_field_base_raw();
       
  4491   return base->obj_field(_static_FALSE_offset);
       
  4492 }
       
  4493 
       
  4494 Symbol* java_lang_Boolean::symbol() {
       
  4495   return vmSymbols::java_lang_Boolean();
       
  4496 }
       
  4497 
       
  4498 #if INCLUDE_CDS
       
  4499 void java_lang_Boolean::serialize_offsets(SerializeClosure* f) {
       
  4500   BOOLEAN_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
       
  4501 }
       
  4502 #endif
       
  4503 #undef BOOLEAN_CACHE_FIELDS_DO
       
  4504 
       
  4505 jboolean java_lang_Boolean::value(oop obj) {
       
  4506    jvalue v;
       
  4507    java_lang_boxing_object::get_value(obj, &v);
       
  4508    return v.z;
       
  4509 }
  4316 
  4510 
  4317 static int member_offset(int hardcoded_offset) {
  4511 static int member_offset(int hardcoded_offset) {
  4318   return (hardcoded_offset * heapOopSize) + instanceOopDesc::base_offset_in_bytes();
  4512   return (hardcoded_offset * heapOopSize) + instanceOopDesc::base_offset_in_bytes();
  4319 }
  4513 }
  4320 
  4514