Mercurial > hg > graal-jvmci-8
comparison src/share/vm/classfile/javaClasses.cpp @ 113:ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv
Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold
author | coleenp |
---|---|
date | Sun, 13 Apr 2008 17:43:42 -0400 |
parents | deb97b8ef02b |
children | 60b728ec77c1 |
comparison
equal
deleted
inserted
replaced
110:a49a647afe9a | 113:ba764ed4b6f2 |
---|---|
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); |