< prev index next >

src/hotspot/share/classfile/javaClasses.cpp

Print this page




 181 #define STRING_FIELDS_DO(macro) \
 182   macro(value_offset, k, vmSymbols::value_name(), byte_array_signature, false); \
 183   macro(hash_offset,  k, "hash",                  int_signature,        false); \
 184   macro(hashIsZero_offset, k, "hashIsZero",       bool_signature,       false); \
 185   macro(coder_offset, k, "coder",                 byte_signature,       false);
 186 
 187 void java_lang_String::compute_offsets() {
 188   if (initialized) {
 189     return;
 190   }
 191 
 192   InstanceKlass* k = SystemDictionary::String_klass();
 193   STRING_FIELDS_DO(FIELD_COMPUTE_OFFSET);
 194 
 195   initialized = true;
 196 }
 197 
 198 #if INCLUDE_CDS
 199 void java_lang_String::serialize_offsets(SerializeClosure* f) {
 200   STRING_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
 201   f->do_bool(&initialized);
 202 }
 203 #endif
 204 
 205 class CompactStringsFixup : public FieldClosure {
 206 private:
 207   bool _value;
 208 
 209 public:
 210   CompactStringsFixup(bool value) : _value(value) {}
 211 
 212   void do_field(fieldDescriptor* fd) {
 213     if (fd->name() == vmSymbols::compact_strings_name()) {
 214       oop mirror = fd->field_holder()->java_mirror();
 215       assert(fd->field_holder() == SystemDictionary::String_klass(), "Should be String");
 216       assert(mirror != NULL, "String must have mirror already");
 217       mirror->bool_field_put(fd->offset(), _value);
 218     }
 219   }
 220 };
 221 


1549 void java_lang_Class::compute_offsets() {
1550   if (offsets_computed) {
1551     return;
1552   }
1553 
1554   offsets_computed = true;
1555 
1556   InstanceKlass* k = SystemDictionary::Class_klass();
1557   CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1558 
1559   // Init lock is a C union with component_mirror.  Only instanceKlass mirrors have
1560   // init_lock and only ArrayKlass mirrors have component_mirror.  Since both are oops
1561   // GC treats them the same.
1562   _init_lock_offset = _component_mirror_offset;
1563 
1564   CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1565 }
1566 
1567 #if INCLUDE_CDS
1568 void java_lang_Class::serialize_offsets(SerializeClosure* f) {
1569   f->do_bool(&offsets_computed);
1570   f->do_u4((u4*)&_init_lock_offset);
1571 
1572   CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1573 
1574   CLASS_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
1575 }
1576 #endif
1577 
1578 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
1579   if (classRedefinedCount_offset == -1) {
1580     // If we don't have an offset for it then just return -1 as a marker.
1581     return -1;
1582   }
1583 
1584   return the_class_mirror->int_field(classRedefinedCount_offset);
1585 }
1586 
1587 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
1588   if (classRedefinedCount_offset == -1) {
1589     // If we don't have an offset for it then nothing to set.


4138 int java_lang_StackTraceElement::moduleVersion_offset;
4139 int java_lang_StackTraceElement::classLoaderName_offset;
4140 int java_lang_StackTraceElement::declaringClass_offset;
4141 int java_lang_StackTraceElement::declaringClassObject_offset;
4142 int java_lang_StackFrameInfo::_memberName_offset;
4143 int java_lang_StackFrameInfo::_bci_offset;
4144 int java_lang_StackFrameInfo::_version_offset;
4145 int java_lang_LiveStackFrameInfo::_monitors_offset;
4146 int java_lang_LiveStackFrameInfo::_locals_offset;
4147 int java_lang_LiveStackFrameInfo::_operands_offset;
4148 int java_lang_LiveStackFrameInfo::_mode_offset;
4149 int java_lang_AssertionStatusDirectives::classes_offset;
4150 int java_lang_AssertionStatusDirectives::classEnabled_offset;
4151 int java_lang_AssertionStatusDirectives::packages_offset;
4152 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
4153 int java_lang_AssertionStatusDirectives::deflt_offset;
4154 int java_nio_Buffer::_limit_offset;
4155 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset;
4156 int reflect_ConstantPool::_oop_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 
4166 
4167 
4168 #define STACKTRACEELEMENT_FIELDS_DO(macro) \
4169   macro(declaringClassObject_offset,  k, "declaringClassObject", class_signature, false); \
4170   macro(classLoaderName_offset, k, "classLoaderName", string_signature, false); \
4171   macro(moduleName_offset,      k, "moduleName",      string_signature, false); \
4172   macro(moduleVersion_offset,   k, "moduleVersion",   string_signature, false); \
4173   macro(declaringClass_offset,  k, "declaringClass",  string_signature, false); \
4174   macro(methodName_offset,      k, "methodName",      string_signature, false); \
4175   macro(fileName_offset,        k, "fileName",        string_signature, false); \
4176   macro(lineNumber_offset,      k, "lineNumber",      int_signature,    false)
4177 
4178 // Support for java_lang_StackTraceElement
4179 void java_lang_StackTraceElement::compute_offsets() {
4180   InstanceKlass* k = SystemDictionary::StackTraceElement_klass();
4181   STACKTRACEELEMENT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4182 }
4183 
4184 #if INCLUDE_CDS
4185 void java_lang_StackTraceElement::serialize_offsets(SerializeClosure* f) {


4304 #endif
4305 
4306 #define AOS_FIELDS_DO(macro) \
4307   macro(_owner_offset, k, "exclusiveOwnerThread", thread_signature, false)
4308 
4309 void java_util_concurrent_locks_AbstractOwnableSynchronizer::compute_offsets() {
4310   InstanceKlass* k = SystemDictionary::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass();
4311   AOS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4312 }
4313 
4314 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
4315   assert(_owner_offset != 0, "Must be initialized");
4316   return obj->obj_field(_owner_offset);
4317 }
4318 
4319 #if INCLUDE_CDS
4320 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize_offsets(SerializeClosure* f) {
4321   AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4322 }
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 }
4510 
4511 static int member_offset(int hardcoded_offset) {
4512   return (hardcoded_offset * heapOopSize) + instanceOopDesc::base_offset_in_bytes();
4513 }
4514 
4515 // Compute hard-coded offsets
4516 // Invoked before SystemDictionary::initialize, so pre-loaded classes
4517 // are not available to determine the offset_of_static_fields.
4518 void JavaClasses::compute_hard_coded_offsets() {
4519 
4520   // java_lang_boxing_object
4521   java_lang_boxing_object::value_offset      = member_offset(java_lang_boxing_object::hc_value_offset);
4522   java_lang_boxing_object::long_value_offset = align_up(member_offset(java_lang_boxing_object::hc_value_offset), BytesPerLong);
4523 
4524   // java_lang_ref_Reference
4525   java_lang_ref_Reference::referent_offset    = member_offset(java_lang_ref_Reference::hc_referent_offset);
4526   java_lang_ref_Reference::queue_offset       = member_offset(java_lang_ref_Reference::hc_queue_offset);
4527   java_lang_ref_Reference::next_offset        = member_offset(java_lang_ref_Reference::hc_next_offset);
4528   java_lang_ref_Reference::discovered_offset  = member_offset(java_lang_ref_Reference::hc_discovered_offset);
4529 }




 181 #define STRING_FIELDS_DO(macro) \
 182   macro(value_offset, k, vmSymbols::value_name(), byte_array_signature, false); \
 183   macro(hash_offset,  k, "hash",                  int_signature,        false); \
 184   macro(hashIsZero_offset, k, "hashIsZero",       bool_signature,       false); \
 185   macro(coder_offset, k, "coder",                 byte_signature,       false);
 186 
 187 void java_lang_String::compute_offsets() {
 188   if (initialized) {
 189     return;
 190   }
 191 
 192   InstanceKlass* k = SystemDictionary::String_klass();
 193   STRING_FIELDS_DO(FIELD_COMPUTE_OFFSET);
 194 
 195   initialized = true;
 196 }
 197 
 198 #if INCLUDE_CDS
 199 void java_lang_String::serialize_offsets(SerializeClosure* f) {
 200   STRING_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
 201   f->do_u4((u4*)&initialized);
 202 }
 203 #endif
 204 
 205 class CompactStringsFixup : public FieldClosure {
 206 private:
 207   bool _value;
 208 
 209 public:
 210   CompactStringsFixup(bool value) : _value(value) {}
 211 
 212   void do_field(fieldDescriptor* fd) {
 213     if (fd->name() == vmSymbols::compact_strings_name()) {
 214       oop mirror = fd->field_holder()->java_mirror();
 215       assert(fd->field_holder() == SystemDictionary::String_klass(), "Should be String");
 216       assert(mirror != NULL, "String must have mirror already");
 217       mirror->bool_field_put(fd->offset(), _value);
 218     }
 219   }
 220 };
 221 


1549 void java_lang_Class::compute_offsets() {
1550   if (offsets_computed) {
1551     return;
1552   }
1553 
1554   offsets_computed = true;
1555 
1556   InstanceKlass* k = SystemDictionary::Class_klass();
1557   CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1558 
1559   // Init lock is a C union with component_mirror.  Only instanceKlass mirrors have
1560   // init_lock and only ArrayKlass mirrors have component_mirror.  Since both are oops
1561   // GC treats them the same.
1562   _init_lock_offset = _component_mirror_offset;
1563 
1564   CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1565 }
1566 
1567 #if INCLUDE_CDS
1568 void java_lang_Class::serialize_offsets(SerializeClosure* f) {
1569   f->do_u4((u4*)&offsets_computed);
1570   f->do_u4((u4*)&_init_lock_offset);
1571 
1572   CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1573 
1574   CLASS_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
1575 }
1576 #endif
1577 
1578 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
1579   if (classRedefinedCount_offset == -1) {
1580     // If we don't have an offset for it then just return -1 as a marker.
1581     return -1;
1582   }
1583 
1584   return the_class_mirror->int_field(classRedefinedCount_offset);
1585 }
1586 
1587 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
1588   if (classRedefinedCount_offset == -1) {
1589     // If we don't have an offset for it then nothing to set.


4138 int java_lang_StackTraceElement::moduleVersion_offset;
4139 int java_lang_StackTraceElement::classLoaderName_offset;
4140 int java_lang_StackTraceElement::declaringClass_offset;
4141 int java_lang_StackTraceElement::declaringClassObject_offset;
4142 int java_lang_StackFrameInfo::_memberName_offset;
4143 int java_lang_StackFrameInfo::_bci_offset;
4144 int java_lang_StackFrameInfo::_version_offset;
4145 int java_lang_LiveStackFrameInfo::_monitors_offset;
4146 int java_lang_LiveStackFrameInfo::_locals_offset;
4147 int java_lang_LiveStackFrameInfo::_operands_offset;
4148 int java_lang_LiveStackFrameInfo::_mode_offset;
4149 int java_lang_AssertionStatusDirectives::classes_offset;
4150 int java_lang_AssertionStatusDirectives::classEnabled_offset;
4151 int java_lang_AssertionStatusDirectives::packages_offset;
4152 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
4153 int java_lang_AssertionStatusDirectives::deflt_offset;
4154 int java_nio_Buffer::_limit_offset;
4155 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset;
4156 int reflect_ConstantPool::_oop_offset;
4157 int reflect_UnsafeStaticFieldAccessorImpl::_base_offset;








4158 
4159 
4160 #define STACKTRACEELEMENT_FIELDS_DO(macro) \
4161   macro(declaringClassObject_offset,  k, "declaringClassObject", class_signature, false); \
4162   macro(classLoaderName_offset, k, "classLoaderName", string_signature, false); \
4163   macro(moduleName_offset,      k, "moduleName",      string_signature, false); \
4164   macro(moduleVersion_offset,   k, "moduleVersion",   string_signature, false); \
4165   macro(declaringClass_offset,  k, "declaringClass",  string_signature, false); \
4166   macro(methodName_offset,      k, "methodName",      string_signature, false); \
4167   macro(fileName_offset,        k, "fileName",        string_signature, false); \
4168   macro(lineNumber_offset,      k, "lineNumber",      int_signature,    false)
4169 
4170 // Support for java_lang_StackTraceElement
4171 void java_lang_StackTraceElement::compute_offsets() {
4172   InstanceKlass* k = SystemDictionary::StackTraceElement_klass();
4173   STACKTRACEELEMENT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4174 }
4175 
4176 #if INCLUDE_CDS
4177 void java_lang_StackTraceElement::serialize_offsets(SerializeClosure* f) {


4296 #endif
4297 
4298 #define AOS_FIELDS_DO(macro) \
4299   macro(_owner_offset, k, "exclusiveOwnerThread", thread_signature, false)
4300 
4301 void java_util_concurrent_locks_AbstractOwnableSynchronizer::compute_offsets() {
4302   InstanceKlass* k = SystemDictionary::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass();
4303   AOS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4304 }
4305 
4306 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
4307   assert(_owner_offset != 0, "Must be initialized");
4308   return obj->obj_field(_owner_offset);
4309 }
4310 
4311 #if INCLUDE_CDS
4312 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize_offsets(SerializeClosure* f) {
4313   AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4314 }
4315 #endif


























































































































































































4316 
4317 static int member_offset(int hardcoded_offset) {
4318   return (hardcoded_offset * heapOopSize) + instanceOopDesc::base_offset_in_bytes();
4319 }
4320 
4321 // Compute hard-coded offsets
4322 // Invoked before SystemDictionary::initialize, so pre-loaded classes
4323 // are not available to determine the offset_of_static_fields.
4324 void JavaClasses::compute_hard_coded_offsets() {
4325 
4326   // java_lang_boxing_object
4327   java_lang_boxing_object::value_offset      = member_offset(java_lang_boxing_object::hc_value_offset);
4328   java_lang_boxing_object::long_value_offset = align_up(member_offset(java_lang_boxing_object::hc_value_offset), BytesPerLong);
4329 
4330   // java_lang_ref_Reference
4331   java_lang_ref_Reference::referent_offset    = member_offset(java_lang_ref_Reference::hc_referent_offset);
4332   java_lang_ref_Reference::queue_offset       = member_offset(java_lang_ref_Reference::hc_queue_offset);
4333   java_lang_ref_Reference::next_offset        = member_offset(java_lang_ref_Reference::hc_next_offset);
4334   java_lang_ref_Reference::discovered_offset  = member_offset(java_lang_ref_Reference::hc_discovered_offset);
4335 }


< prev index next >