Mercurial > hg > truffle

comparison src/share/vm/classfile/javaClasses.cpp @ 113:ba764ed4b6f2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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);