518 vmSymbols::long_signature()); |
518 vmSymbols::long_signature()); |
519 } |
519 } |
520 |
520 |
521 |
521 |
522 JavaThread* java_lang_Thread::thread(oop java_thread) { |
522 JavaThread* java_lang_Thread::thread(oop java_thread) { |
523 return (JavaThread*) java_thread->obj_field(_eetop_offset); |
523 return (JavaThread*)java_thread->address_field(_eetop_offset); |
524 } |
524 } |
525 |
525 |
526 |
526 |
527 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) { |
527 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) { |
528 // We are storing a JavaThread* (malloc'ed data) into a long field in the thread |
528 java_thread->address_field_put(_eetop_offset, (address)thread); |
529 // object. The store has to be 64-bit wide so we use a pointer store, but we |
|
530 // cannot call oopDesc::obj_field_put since it includes a write barrier! |
|
531 oop* addr = java_thread->obj_field_addr(_eetop_offset); |
|
532 *addr = (oop) thread; |
|
533 } |
529 } |
534 |
530 |
535 |
531 |
536 typeArrayOop java_lang_Thread::name(oop java_thread) { |
532 typeArrayOop java_lang_Thread::name(oop java_thread) { |
537 oop name = java_thread->obj_field(_name_offset); |
533 oop name = java_thread->obj_field(_name_offset); |
1036 |
1032 |
1037 void flush() { |
1033 void flush() { |
1038 if (_dirty && _methods != NULL) { |
1034 if (_dirty && _methods != NULL) { |
1039 BarrierSet* bs = Universe::heap()->barrier_set(); |
1035 BarrierSet* bs = Universe::heap()->barrier_set(); |
1040 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); |
1036 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); |
1041 bs->write_ref_array(MemRegion((HeapWord*)_methods->obj_at_addr(0), |
1037 bs->write_ref_array(MemRegion((HeapWord*)_methods->base(), |
1042 _methods->length() * HeapWordsPerOop)); |
1038 _methods->array_size())); |
1043 _dirty = false; |
1039 _dirty = false; |
1044 } |
1040 } |
1045 } |
1041 } |
1046 |
1042 |
1047 void expand(TRAPS) { |
1043 void expand(TRAPS) { |
1081 methodHandle mhandle(THREAD, method); |
1077 methodHandle mhandle(THREAD, method); |
1082 expand(CHECK); |
1078 expand(CHECK); |
1083 method = mhandle(); |
1079 method = mhandle(); |
1084 } |
1080 } |
1085 |
1081 |
1086 // _methods->obj_at_put(_index, method); |
1082 _methods->obj_at_put(_index, method); |
1087 *_methods->obj_at_addr(_index) = method; |
1083 // bad for UseCompressedOops |
|
1084 // *_methods->obj_at_addr(_index) = method; |
1088 _bcis->ushort_at_put(_index, bci); |
1085 _bcis->ushort_at_put(_index, bci); |
1089 _index++; |
1086 _index++; |
1090 _dirty = true; |
1087 _dirty = true; |
1091 } |
1088 } |
1092 |
1089 |
1971 return T_ILLEGAL; |
1968 return T_ILLEGAL; |
1972 } |
1969 } |
1973 |
1970 |
1974 |
1971 |
1975 // Support for java_lang_ref_Reference |
1972 // Support for java_lang_ref_Reference |
1976 |
1973 oop java_lang_ref_Reference::pending_list_lock() { |
1977 void java_lang_ref_Reference::set_referent(oop ref, oop value) { |
|
1978 ref->obj_field_put(referent_offset, value); |
|
1979 } |
|
1980 |
|
1981 oop* java_lang_ref_Reference::referent_addr(oop ref) { |
|
1982 return ref->obj_field_addr(referent_offset); |
|
1983 } |
|
1984 |
|
1985 void java_lang_ref_Reference::set_next(oop ref, oop value) { |
|
1986 ref->obj_field_put(next_offset, value); |
|
1987 } |
|
1988 |
|
1989 oop* java_lang_ref_Reference::next_addr(oop ref) { |
|
1990 return ref->obj_field_addr(next_offset); |
|
1991 } |
|
1992 |
|
1993 void java_lang_ref_Reference::set_discovered(oop ref, oop value) { |
|
1994 ref->obj_field_put(discovered_offset, value); |
|
1995 } |
|
1996 |
|
1997 oop* java_lang_ref_Reference::discovered_addr(oop ref) { |
|
1998 return ref->obj_field_addr(discovered_offset); |
|
1999 } |
|
2000 |
|
2001 oop* java_lang_ref_Reference::pending_list_lock_addr() { |
|
2002 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass()); |
1974 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass()); |
2003 return (oop*)(((char *)ik->start_of_static_fields()) + static_lock_offset); |
1975 char *addr = (((char *)ik->start_of_static_fields()) + static_lock_offset); |
2004 } |
1976 if (UseCompressedOops) { |
2005 |
1977 return oopDesc::load_decode_heap_oop((narrowOop *)addr); |
2006 oop* java_lang_ref_Reference::pending_list_addr() { |
1978 } else { |
|
1979 return oopDesc::load_decode_heap_oop((oop*)addr); |
|
1980 } |
|
1981 } |
|
1982 |
|
1983 HeapWord *java_lang_ref_Reference::pending_list_addr() { |
2007 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass()); |
1984 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass()); |
2008 return (oop *)(((char *)ik->start_of_static_fields()) + static_pending_offset); |
1985 char *addr = (((char *)ik->start_of_static_fields()) + static_pending_offset); |
|
1986 // XXX This might not be HeapWord aligned, almost rather be char *. |
|
1987 return (HeapWord*)addr; |
|
1988 } |
|
1989 |
|
1990 oop java_lang_ref_Reference::pending_list() { |
|
1991 char *addr = (char *)pending_list_addr(); |
|
1992 if (UseCompressedOops) { |
|
1993 return oopDesc::load_decode_heap_oop((narrowOop *)addr); |
|
1994 } else { |
|
1995 return oopDesc::load_decode_heap_oop((oop*)addr); |
|
1996 } |
2009 } |
1997 } |
2010 |
1998 |
2011 |
1999 |
2012 // Support for java_lang_ref_SoftReference |
2000 // Support for java_lang_ref_SoftReference |
2013 |
2001 |
2289 |
2277 |
2290 // Compute hard-coded offsets |
2278 // Compute hard-coded offsets |
2291 // Invoked before SystemDictionary::initialize, so pre-loaded classes |
2279 // Invoked before SystemDictionary::initialize, so pre-loaded classes |
2292 // are not available to determine the offset_of_static_fields. |
2280 // are not available to determine the offset_of_static_fields. |
2293 void JavaClasses::compute_hard_coded_offsets() { |
2281 void JavaClasses::compute_hard_coded_offsets() { |
2294 const int x = wordSize; |
2282 const int x = heapOopSize; |
2295 const int header = instanceOopDesc::header_size_in_bytes(); |
2283 // Objects don't get allocated in the gap in the header with compressed oops |
|
2284 // for these special classes because hard coded offsets can't be conditional |
|
2285 // so base_offset_in_bytes() is wrong here, allocate after the header. |
|
2286 const int header = sizeof(instanceOopDesc); |
2296 |
2287 |
2297 // Do the String Class |
2288 // Do the String Class |
2298 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header; |
2289 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header; |
2299 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header; |
2290 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header; |
2300 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint); |
2291 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint); |