Mercurial > hg > graal-jvmci-8
annotate src/share/vm/classfile/javaClasses.cpp @ 1091:6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
Summary: Introduced a new write_ref_array(HeapWords* start, size_t count) method that does the requisite MemRegion range calculation so (some of the) clients of the erstwhile write_ref_array(MemRegion mr) do not need to worry. This removed all external uses of array_size(), which was also simplified and made private. Asserts were added to catch other possible issues. Further, less essential, fixes stemming from this investigation are deferred to CR 6904516 (to follow shortly in hs17).
Reviewed-by: kvn, coleenp, jmasa
| author | ysr |
|---|---|
| date | Thu, 03 Dec 2009 15:01:57 -0800 |
| parents | 489a4f8dcd0f |
| children | 84a2da7f454c |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 579 | 2 * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 # include "incls/_precompiled.incl" | |
| 26 # include "incls/_javaClasses.cpp.incl" | |
| 27 | |
| 710 | 28 static bool find_field(instanceKlass* ik, |
| 29 symbolOop name_symbol, symbolOop signature_symbol, | |
| 30 fieldDescriptor* fd, | |
| 31 bool allow_super = false) { | |
| 32 if (allow_super) | |
| 33 return ik->find_field(name_symbol, signature_symbol, fd) != NULL; | |
| 34 else | |
| 35 return ik->find_local_field(name_symbol, signature_symbol, fd); | |
| 36 } | |
| 37 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
38 // Helpful routine for computing field offsets at run time rather than hardcoding them |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
39 static void |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
40 compute_offset(int &dest_offset, |
| 710 | 41 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol, |
| 42 bool allow_super = false) { | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
43 fieldDescriptor fd; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
44 instanceKlass* ik = instanceKlass::cast(klass_oop); |
| 710 | 45 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
46 ResourceMark rm; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
47 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
48 fatal("Invalid layout of preloaded class"); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
49 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
50 dest_offset = fd.offset(); |
| 0 | 51 } |
| 52 | |
| 53 // Same as above but for "optional" offsets that might not be present in certain JDK versions | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
54 static void |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
55 compute_optional_offset(int& dest_offset, |
| 710 | 56 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol, |
| 57 bool allow_super = false) { | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
58 fieldDescriptor fd; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
59 instanceKlass* ik = instanceKlass::cast(klass_oop); |
| 710 | 60 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
61 dest_offset = fd.offset(); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
62 } |
| 0 | 63 } |
| 64 | |
| 710 | 65 |
| 0 | 66 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) { |
| 67 // Create the String object first, so there's a chance that the String | |
| 68 // and the char array it points to end up in the same cache line. | |
| 69 oop obj; | |
| 70 if (tenured) { | |
| 71 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH); | |
| 72 } else { | |
| 73 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH); | |
| 74 } | |
| 75 | |
| 76 // Create the char array. The String object must be handlized here | |
| 77 // because GC can happen as a result of the allocation attempt. | |
| 78 Handle h_obj(THREAD, obj); | |
| 79 typeArrayOop buffer; | |
| 80 if (tenured) { | |
| 81 buffer = oopFactory::new_permanent_charArray(length, CHECK_NH); | |
| 82 } else { | |
| 83 buffer = oopFactory::new_charArray(length, CHECK_NH); | |
| 84 } | |
| 85 | |
| 86 // Point the String at the char array | |
| 87 obj = h_obj(); | |
| 88 set_value(obj, buffer); | |
| 89 // No need to zero the offset, allocation zero'ed the entire String object | |
| 90 assert(offset(obj) == 0, "initial String offset should be zero"); | |
| 91 //set_offset(obj, 0); | |
| 92 set_count(obj, length); | |
| 93 | |
| 94 return h_obj; | |
| 95 } | |
| 96 | |
| 97 Handle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) { | |
| 98 Handle h_obj = basic_create(length, tenured, CHECK_NH); | |
| 99 typeArrayOop buffer = value(h_obj()); | |
| 100 for (int index = 0; index < length; index++) { | |
| 101 buffer->char_at_put(index, unicode[index]); | |
| 102 } | |
| 103 return h_obj; | |
| 104 } | |
| 105 | |
| 106 Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) { | |
| 107 return basic_create_from_unicode(unicode, length, false, CHECK_NH); | |
| 108 } | |
| 109 | |
| 110 Handle java_lang_String::create_tenured_from_unicode(jchar* unicode, int length, TRAPS) { | |
| 111 return basic_create_from_unicode(unicode, length, true, CHECK_NH); | |
| 112 } | |
| 113 | |
| 114 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) { | |
| 115 Handle h_obj = basic_create_from_unicode(unicode, length, false, CHECK_0); | |
| 116 return h_obj(); | |
| 117 } | |
| 118 | |
| 119 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) { | |
| 120 if (utf8_str == NULL) { | |
| 121 return Handle(); | |
| 122 } | |
| 123 int length = UTF8::unicode_length(utf8_str); | |
| 124 Handle h_obj = basic_create(length, false, CHECK_NH); | |
| 125 if (length > 0) { | |
| 126 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length); | |
| 127 } | |
| 128 return h_obj; | |
| 129 } | |
| 130 | |
| 131 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) { | |
| 132 Handle h_obj = create_from_str(utf8_str, CHECK_0); | |
| 133 return h_obj(); | |
| 134 } | |
| 135 | |
| 136 Handle java_lang_String::create_from_symbol(symbolHandle symbol, TRAPS) { | |
| 137 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length()); | |
| 138 Handle h_obj = basic_create(length, false, CHECK_NH); | |
| 139 if (length > 0) { | |
| 140 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length); | |
| 141 } | |
| 142 return h_obj; | |
| 143 } | |
| 144 | |
| 145 // Converts a C string to a Java String based on current encoding | |
| 146 Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) { | |
| 147 assert(str != NULL, "bad arguments"); | |
| 148 | |
| 149 typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *); | |
| 150 static to_java_string_fn_t _to_java_string_fn = NULL; | |
| 151 | |
| 152 if (_to_java_string_fn == NULL) { | |
| 153 void *lib_handle = os::native_java_library(); | |
| 154 _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, hpi::dll_lookup(lib_handle, "NewStringPlatform")); | |
| 155 if (_to_java_string_fn == NULL) { | |
| 156 fatal("NewStringPlatform missing"); | |
| 157 } | |
| 158 } | |
| 159 | |
| 160 jstring js = NULL; | |
| 161 { JavaThread* thread = (JavaThread*)THREAD; | |
| 162 assert(thread->is_Java_thread(), "must be java thread"); | |
|
22
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
163 HandleMark hm(thread); |
| 0 | 164 ThreadToNativeFromVM ttn(thread); |
| 165 js = (_to_java_string_fn)(thread->jni_environment(), str); | |
| 166 } | |
| 167 return Handle(THREAD, JNIHandles::resolve(js)); | |
| 168 } | |
| 169 | |
|
22
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
170 // Converts a Java String to a native C string that can be used for |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
171 // native OS calls. |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
172 char* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) { |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
173 |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
174 typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
175 static to_platform_string_fn_t _to_platform_string_fn = NULL; |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
176 |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
177 if (_to_platform_string_fn == NULL) { |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
178 void *lib_handle = os::native_java_library(); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
179 _to_platform_string_fn = CAST_TO_FN_PTR(to_platform_string_fn_t, hpi::dll_lookup(lib_handle, "GetStringPlatformChars")); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
180 if (_to_platform_string_fn == NULL) { |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
181 fatal("GetStringPlatformChars missing"); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
182 } |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
183 } |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
184 |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
185 char *native_platform_string; |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
186 { JavaThread* thread = (JavaThread*)THREAD; |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
187 assert(thread->is_Java_thread(), "must be java thread"); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
188 JNIEnv *env = thread->jni_environment(); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
189 jstring js = (jstring) JNIHandles::make_local(env, java_string()); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
190 bool is_copy; |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
191 HandleMark hm(thread); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
192 ThreadToNativeFromVM ttn(thread); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
193 native_platform_string = (_to_platform_string_fn)(env, js, &is_copy); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
194 assert(is_copy == JNI_TRUE, "is_copy value changed"); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
195 JNIHandles::destroy_local(js); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
196 } |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
197 return native_platform_string; |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
198 } |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
199 |
| 0 | 200 Handle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) { |
| 201 oop obj = java_string(); | |
| 202 // Typical usage is to convert all '/' to '.' in string. | |
| 203 typeArrayOop value = java_lang_String::value(obj); | |
| 204 int offset = java_lang_String::offset(obj); | |
| 205 int length = java_lang_String::length(obj); | |
| 206 | |
| 207 // First check if any from_char exist | |
| 208 int index; // Declared outside, used later | |
| 209 for (index = 0; index < length; index++) { | |
| 210 if (value->char_at(index + offset) == from_char) { | |
| 211 break; | |
| 212 } | |
| 213 } | |
| 214 if (index == length) { | |
| 215 // No from_char, so do not copy. | |
| 216 return java_string; | |
| 217 } | |
| 218 | |
| 219 // Create new UNICODE buffer. Must handlize value because GC | |
| 220 // may happen during String and char array creation. | |
| 221 typeArrayHandle h_value(THREAD, value); | |
| 222 Handle string = basic_create(length, false, CHECK_NH); | |
| 223 | |
| 224 typeArrayOop from_buffer = h_value(); | |
| 225 typeArrayOop to_buffer = java_lang_String::value(string()); | |
| 226 | |
| 227 // Copy contents | |
| 228 for (index = 0; index < length; index++) { | |
| 229 jchar c = from_buffer->char_at(index + offset); | |
| 230 if (c == from_char) { | |
| 231 c = to_char; | |
| 232 } | |
| 233 to_buffer->char_at_put(index, c); | |
| 234 } | |
| 235 return string; | |
| 236 } | |
| 237 | |
| 238 jchar* java_lang_String::as_unicode_string(oop java_string, int& length) { | |
| 239 typeArrayOop value = java_lang_String::value(java_string); | |
| 240 int offset = java_lang_String::offset(java_string); | |
| 241 length = java_lang_String::length(java_string); | |
| 242 | |
| 243 jchar* result = NEW_RESOURCE_ARRAY(jchar, length); | |
| 244 for (int index = 0; index < length; index++) { | |
| 245 result[index] = value->char_at(index + offset); | |
| 246 } | |
| 247 return result; | |
| 248 } | |
| 249 | |
| 250 symbolHandle java_lang_String::as_symbol(Handle java_string, TRAPS) { | |
| 251 oop obj = java_string(); | |
| 252 typeArrayOop value = java_lang_String::value(obj); | |
| 253 int offset = java_lang_String::offset(obj); | |
| 254 int length = java_lang_String::length(obj); | |
|
949
489a4f8dcd0f
6865583: Verbose CIPrintMethodCodes asserts when ldc an empty String
twisti
parents:
931
diff
changeset
|
255 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
256 symbolOop sym = SymbolTable::lookup_unicode(base, length, THREAD); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
257 return symbolHandle(THREAD, sym); |
| 0 | 258 } |
| 259 | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
260 symbolOop java_lang_String::as_symbol_or_null(oop java_string) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
261 typeArrayOop value = java_lang_String::value(java_string); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
262 int offset = java_lang_String::offset(java_string); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
263 int length = java_lang_String::length(java_string); |
|
949
489a4f8dcd0f
6865583: Verbose CIPrintMethodCodes asserts when ldc an empty String
twisti
parents:
931
diff
changeset
|
264 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
265 return SymbolTable::probe_unicode(base, length); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
266 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
267 |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
268 |
| 0 | 269 int java_lang_String::utf8_length(oop java_string) { |
| 270 typeArrayOop value = java_lang_String::value(java_string); | |
| 271 int offset = java_lang_String::offset(java_string); | |
| 272 int length = java_lang_String::length(java_string); | |
| 273 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); | |
| 274 return UNICODE::utf8_length(position, length); | |
| 275 } | |
| 276 | |
| 277 char* java_lang_String::as_utf8_string(oop java_string) { | |
| 278 typeArrayOop value = java_lang_String::value(java_string); | |
| 279 int offset = java_lang_String::offset(java_string); | |
| 280 int length = java_lang_String::length(java_string); | |
| 281 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset); | |
| 282 return UNICODE::as_utf8(position, length); | |
| 283 } | |
| 284 | |
| 285 char* java_lang_String::as_utf8_string(oop java_string, int start, int len) { | |
| 286 typeArrayOop value = java_lang_String::value(java_string); | |
| 287 int offset = java_lang_String::offset(java_string); | |
| 288 int length = java_lang_String::length(java_string); | |
| 289 assert(start + len <= length, "just checking"); | |
| 290 jchar* position = value->char_at_addr(offset + start); | |
| 291 return UNICODE::as_utf8(position, len); | |
| 292 } | |
| 293 | |
| 294 bool java_lang_String::equals(oop java_string, jchar* chars, int len) { | |
| 295 assert(SharedSkipVerify || | |
| 296 java_string->klass() == SystemDictionary::string_klass(), | |
| 297 "must be java_string"); | |
| 298 typeArrayOop value = java_lang_String::value(java_string); | |
| 299 int offset = java_lang_String::offset(java_string); | |
| 300 int length = java_lang_String::length(java_string); | |
| 301 if (length != len) { | |
| 302 return false; | |
| 303 } | |
| 304 for (int i = 0; i < len; i++) { | |
| 305 if (value->char_at(i + offset) != chars[i]) { | |
| 306 return false; | |
| 307 } | |
| 308 } | |
| 309 return true; | |
| 310 } | |
| 311 | |
| 312 void java_lang_String::print(Handle java_string, outputStream* st) { | |
| 313 oop obj = java_string(); | |
| 314 assert(obj->klass() == SystemDictionary::string_klass(), "must be java_string"); | |
| 315 typeArrayOop value = java_lang_String::value(obj); | |
| 316 int offset = java_lang_String::offset(obj); | |
| 317 int length = java_lang_String::length(obj); | |
| 318 | |
| 319 int end = MIN2(length, 100); | |
| 320 if (value == NULL) { | |
| 321 // This can happen if, e.g., printing a String | |
| 322 // object before its initializer has been called | |
| 323 st->print_cr("NULL"); | |
| 324 } else { | |
| 325 st->print("\""); | |
| 326 for (int index = 0; index < length; index++) { | |
| 327 st->print("%c", value->char_at(index + offset)); | |
| 328 } | |
| 329 st->print("\""); | |
| 330 } | |
| 331 } | |
| 332 | |
| 333 | |
| 334 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) { | |
| 335 assert(k->java_mirror() == NULL, "should only assign mirror once"); | |
| 336 // Use this moment of initialization to cache modifier_flags also, | |
| 337 // to support Class.getModifiers(). Instance classes recalculate | |
| 338 // the cached flags after the class file is parsed, but before the | |
| 339 // class is put into the system dictionary. | |
| 340 int computed_modifiers = k->compute_modifier_flags(CHECK_0); | |
| 341 k->set_modifier_flags(computed_modifiers); | |
| 342 if (SystemDictionary::class_klass_loaded()) { | |
| 343 // Allocate mirror (java.lang.Class instance) | |
| 344 Handle mirror = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0); | |
| 345 // Setup indirections | |
| 346 mirror->obj_field_put(klass_offset, k()); | |
| 347 k->set_java_mirror(mirror()); | |
| 348 // It might also have a component mirror. This mirror must already exist. | |
| 349 if (k->oop_is_javaArray()) { | |
| 350 Handle comp_mirror; | |
| 351 if (k->oop_is_typeArray()) { | |
| 352 BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type(); | |
| 353 comp_mirror = Universe::java_mirror(type); | |
| 354 assert(comp_mirror.not_null(), "must have primitive mirror"); | |
| 355 } else if (k->oop_is_objArray()) { | |
| 356 klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass(); | |
| 357 if (element_klass != NULL | |
| 358 && (Klass::cast(element_klass)->oop_is_instance() || | |
| 359 Klass::cast(element_klass)->oop_is_javaArray())) { | |
| 360 comp_mirror = Klass::cast(element_klass)->java_mirror(); | |
| 361 assert(comp_mirror.not_null(), "must have element mirror"); | |
| 362 } | |
| 363 // else some object array internal to the VM, like systemObjArrayKlassObj | |
| 364 } | |
| 365 if (comp_mirror.not_null()) { | |
| 366 // Two-way link between the array klass and its component mirror: | |
| 367 arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror()); | |
| 368 set_array_klass(comp_mirror(), k->as_klassOop()); | |
| 369 } | |
| 370 } | |
| 371 return mirror(); | |
| 372 } else { | |
| 373 return NULL; | |
| 374 } | |
| 375 } | |
| 376 | |
| 377 | |
| 378 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) { | |
| 379 // This should be improved by adding a field at the Java level or by | |
| 380 // introducing a new VM klass (see comment in ClassFileParser) | |
| 381 oop java_class = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0); | |
| 382 if (type != T_VOID) { | |
| 383 klassOop aklass = Universe::typeArrayKlassObj(type); | |
| 384 assert(aklass != NULL, "correct bootstrap"); | |
| 385 set_array_klass(java_class, aklass); | |
| 386 } | |
| 387 return java_class; | |
| 388 } | |
| 389 | |
| 390 | |
| 391 klassOop java_lang_Class::as_klassOop(oop java_class) { | |
| 392 //%note memory_2 | |
| 393 klassOop k = klassOop(java_class->obj_field(klass_offset)); | |
| 394 assert(k == NULL || k->is_klass(), "type check"); | |
| 395 return k; | |
| 396 } | |
| 397 | |
| 398 | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
399 void java_lang_Class::print_signature(oop java_class, outputStream* st) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
400 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
401 symbolOop name = NULL; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
402 bool is_instance = false; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
403 if (is_primitive(java_class)) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
404 name = vmSymbols::type_signature(primitive_type(java_class)); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
405 } else { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
406 klassOop k = as_klassOop(java_class); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
407 is_instance = Klass::cast(k)->oop_is_instance(); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
408 name = Klass::cast(k)->name(); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
409 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
410 if (name == NULL) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
411 st->print("<null>"); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
412 return; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
413 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
414 if (is_instance) st->print("L"); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
415 st->write((char*) name->base(), (int) name->utf8_length()); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
416 if (is_instance) st->print(";"); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
417 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
418 |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
419 symbolOop java_lang_Class::as_signature(oop java_class, bool intern_if_not_found, TRAPS) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
420 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
421 symbolOop name = NULL; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
422 if (is_primitive(java_class)) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
423 return vmSymbols::type_signature(primitive_type(java_class)); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
424 } else { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
425 klassOop k = as_klassOop(java_class); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
426 if (!Klass::cast(k)->oop_is_instance()) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
427 return Klass::cast(k)->name(); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
428 } else { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
429 ResourceMark rm; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
430 const char* sigstr = Klass::cast(k)->signature_name(); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
431 int siglen = (int) strlen(sigstr); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
432 if (!intern_if_not_found) |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
433 return SymbolTable::probe(sigstr, siglen); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
434 else |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
435 return oopFactory::new_symbol(sigstr, siglen, THREAD); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
436 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
437 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
438 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
439 |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
440 |
| 0 | 441 klassOop java_lang_Class::array_klass(oop java_class) { |
| 442 klassOop k = klassOop(java_class->obj_field(array_klass_offset)); | |
| 443 assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass"); | |
| 444 return k; | |
| 445 } | |
| 446 | |
| 447 | |
| 448 void java_lang_Class::set_array_klass(oop java_class, klassOop klass) { | |
| 449 assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass"); | |
| 450 java_class->obj_field_put(array_klass_offset, klass); | |
| 451 } | |
| 452 | |
| 453 | |
| 454 methodOop java_lang_Class::resolved_constructor(oop java_class) { | |
| 455 oop constructor = java_class->obj_field(resolved_constructor_offset); | |
| 456 assert(constructor == NULL || constructor->is_method(), "should be method"); | |
| 457 return methodOop(constructor); | |
| 458 } | |
| 459 | |
| 460 | |
| 461 void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) { | |
| 462 assert(constructor->is_method(), "should be method"); | |
| 463 java_class->obj_field_put(resolved_constructor_offset, constructor); | |
| 464 } | |
| 465 | |
| 466 | |
| 467 bool java_lang_Class::is_primitive(oop java_class) { | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
468 // should assert: |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
469 //assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
| 0 | 470 klassOop k = klassOop(java_class->obj_field(klass_offset)); |
| 471 return k == NULL; | |
| 472 } | |
| 473 | |
| 474 | |
| 475 BasicType java_lang_Class::primitive_type(oop java_class) { | |
| 476 assert(java_lang_Class::is_primitive(java_class), "just checking"); | |
| 477 klassOop ak = klassOop(java_class->obj_field(array_klass_offset)); | |
| 478 BasicType type = T_VOID; | |
| 479 if (ak != NULL) { | |
| 480 // Note: create_basic_type_mirror above initializes ak to a non-null value. | |
| 481 type = arrayKlass::cast(ak)->element_type(); | |
| 482 } else { | |
| 483 assert(java_class == Universe::void_mirror(), "only valid non-array primitive"); | |
| 484 } | |
| 485 assert(Universe::java_mirror(type) == java_class, "must be consistent"); | |
| 486 return type; | |
| 487 } | |
| 488 | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
489 BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klass) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
490 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
491 if (is_primitive(java_class)) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
492 if (reference_klass != NULL) |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
493 (*reference_klass) = NULL; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
494 return primitive_type(java_class); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
495 } else { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
496 if (reference_klass != NULL) |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
497 (*reference_klass) = as_klassOop(java_class); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
498 return T_OBJECT; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
499 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
500 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
501 |
| 0 | 502 |
| 503 oop java_lang_Class::primitive_mirror(BasicType t) { | |
| 504 oop mirror = Universe::java_mirror(t); | |
| 505 assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class"); | |
| 506 assert(java_lang_Class::is_primitive(mirror), "must be primitive"); | |
| 507 return mirror; | |
| 508 } | |
| 509 | |
| 510 bool java_lang_Class::offsets_computed = false; | |
| 511 int java_lang_Class::classRedefinedCount_offset = -1; | |
| 514 | 512 int java_lang_Class::parallelCapable_offset = -1; |
| 0 | 513 |
| 514 void java_lang_Class::compute_offsets() { | |
| 515 assert(!offsets_computed, "offsets should be initialized only once"); | |
| 516 offsets_computed = true; | |
| 517 | |
| 518 klassOop k = SystemDictionary::class_klass(); | |
| 519 // The classRedefinedCount field is only present starting in 1.5, | |
| 520 // so don't go fatal. | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
521 compute_optional_offset(classRedefinedCount_offset, |
| 0 | 522 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature()); |
| 514 | 523 |
| 524 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7, | |
| 525 klassOop k1 = SystemDictionary::classloader_klass(); | |
| 526 compute_optional_offset(parallelCapable_offset, | |
| 527 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature()); | |
| 528 } | |
| 529 | |
| 530 // For class loader classes, parallelCapable defined | |
| 531 // based on non-null field | |
| 532 // Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it | |
| 533 bool java_lang_Class::parallelCapable(oop class_loader) { | |
| 534 if (!JDK_Version::is_gte_jdk17x_version() | |
| 535 || parallelCapable_offset == -1) { | |
| 536 // Default for backward compatibility is false | |
| 537 return false; | |
| 538 } | |
| 539 return (class_loader->obj_field(parallelCapable_offset) != NULL); | |
| 0 | 540 } |
| 541 | |
| 542 int java_lang_Class::classRedefinedCount(oop the_class_mirror) { | |
| 543 if (!JDK_Version::is_gte_jdk15x_version() | |
| 544 || classRedefinedCount_offset == -1) { | |
| 545 // The classRedefinedCount field is only present starting in 1.5. | |
| 546 // If we don't have an offset for it then just return -1 as a marker. | |
| 547 return -1; | |
| 548 } | |
| 549 | |
| 550 return the_class_mirror->int_field(classRedefinedCount_offset); | |
| 551 } | |
| 552 | |
| 553 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) { | |
| 554 if (!JDK_Version::is_gte_jdk15x_version() | |
| 555 || classRedefinedCount_offset == -1) { | |
| 556 // The classRedefinedCount field is only present starting in 1.5. | |
| 557 // If we don't have an offset for it then nothing to set. | |
| 558 return; | |
| 559 } | |
| 560 | |
| 561 the_class_mirror->int_field_put(classRedefinedCount_offset, value); | |
| 562 } | |
| 563 | |
| 564 | |
| 565 // Note: JDK1.1 and before had a privateInfo_offset field which was used for the | |
| 566 // platform thread structure, and a eetop offset which was used for thread | |
| 567 // local storage (and unused by the HotSpot VM). In JDK1.2 the two structures | |
| 568 // merged, so in the HotSpot VM we just use the eetop field for the thread | |
| 569 // instead of the privateInfo_offset. | |
| 570 // | |
| 571 // Note: The stackSize field is only present starting in 1.4. | |
| 572 | |
| 573 int java_lang_Thread::_name_offset = 0; | |
| 574 int java_lang_Thread::_group_offset = 0; | |
| 575 int java_lang_Thread::_contextClassLoader_offset = 0; | |
| 576 int java_lang_Thread::_inheritedAccessControlContext_offset = 0; | |
| 577 int java_lang_Thread::_priority_offset = 0; | |
| 578 int java_lang_Thread::_eetop_offset = 0; | |
| 579 int java_lang_Thread::_daemon_offset = 0; | |
| 580 int java_lang_Thread::_stillborn_offset = 0; | |
| 581 int java_lang_Thread::_stackSize_offset = 0; | |
| 582 int java_lang_Thread::_tid_offset = 0; | |
| 583 int java_lang_Thread::_thread_status_offset = 0; | |
| 584 int java_lang_Thread::_park_blocker_offset = 0; | |
| 585 int java_lang_Thread::_park_event_offset = 0 ; | |
| 586 | |
| 587 | |
| 588 void java_lang_Thread::compute_offsets() { | |
| 589 assert(_group_offset == 0, "offsets should be initialized only once"); | |
| 590 | |
| 591 klassOop k = SystemDictionary::thread_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
592 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
593 compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
594 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
595 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
596 compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
597 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
598 compute_offset(_eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
599 compute_offset(_stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature()); |
| 0 | 600 // The stackSize field is only present starting in 1.4, so don't go fatal. |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
601 compute_optional_offset(_stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature()); |
| 0 | 602 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal. |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
603 compute_optional_offset(_tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
604 compute_optional_offset(_thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature()); |
| 0 | 605 // The parkBlocker field is only present starting in 1.6, so don't go fatal. |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
606 compute_optional_offset(_park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
607 compute_optional_offset(_park_event_offset, k, vmSymbols::park_event_name(), |
| 0 | 608 vmSymbols::long_signature()); |
| 609 } | |
| 610 | |
| 611 | |
| 612 JavaThread* java_lang_Thread::thread(oop java_thread) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
613 return (JavaThread*)java_thread->address_field(_eetop_offset); |
| 0 | 614 } |
| 615 | |
| 616 | |
| 617 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
618 java_thread->address_field_put(_eetop_offset, (address)thread); |
| 0 | 619 } |
| 620 | |
| 621 | |
| 622 typeArrayOop java_lang_Thread::name(oop java_thread) { | |
| 623 oop name = java_thread->obj_field(_name_offset); | |
| 624 assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking"); | |
| 625 return typeArrayOop(name); | |
| 626 } | |
| 627 | |
| 628 | |
| 629 void java_lang_Thread::set_name(oop java_thread, typeArrayOop name) { | |
| 630 assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL"); | |
| 631 java_thread->obj_field_put(_name_offset, name); | |
| 632 } | |
| 633 | |
| 634 | |
| 635 ThreadPriority java_lang_Thread::priority(oop java_thread) { | |
| 636 return (ThreadPriority)java_thread->int_field(_priority_offset); | |
| 637 } | |
| 638 | |
| 639 | |
| 640 void java_lang_Thread::set_priority(oop java_thread, ThreadPriority priority) { | |
| 641 java_thread->int_field_put(_priority_offset, priority); | |
| 642 } | |
| 643 | |
| 644 | |
| 645 oop java_lang_Thread::threadGroup(oop java_thread) { | |
| 646 return java_thread->obj_field(_group_offset); | |
| 647 } | |
| 648 | |
| 649 | |
| 650 bool java_lang_Thread::is_stillborn(oop java_thread) { | |
| 651 return java_thread->bool_field(_stillborn_offset) != 0; | |
| 652 } | |
| 653 | |
| 654 | |
| 655 // We never have reason to turn the stillborn bit off | |
| 656 void java_lang_Thread::set_stillborn(oop java_thread) { | |
| 657 java_thread->bool_field_put(_stillborn_offset, true); | |
| 658 } | |
| 659 | |
| 660 | |
| 661 bool java_lang_Thread::is_alive(oop java_thread) { | |
| 662 JavaThread* thr = java_lang_Thread::thread(java_thread); | |
| 663 return (thr != NULL); | |
| 664 } | |
| 665 | |
| 666 | |
| 667 bool java_lang_Thread::is_daemon(oop java_thread) { | |
| 668 return java_thread->bool_field(_daemon_offset) != 0; | |
| 669 } | |
| 670 | |
| 671 | |
| 672 void java_lang_Thread::set_daemon(oop java_thread) { | |
| 673 java_thread->bool_field_put(_daemon_offset, true); | |
| 674 } | |
| 675 | |
| 676 oop java_lang_Thread::context_class_loader(oop java_thread) { | |
| 677 return java_thread->obj_field(_contextClassLoader_offset); | |
| 678 } | |
| 679 | |
| 680 oop java_lang_Thread::inherited_access_control_context(oop java_thread) { | |
| 681 return java_thread->obj_field(_inheritedAccessControlContext_offset); | |
| 682 } | |
| 683 | |
| 684 | |
| 685 jlong java_lang_Thread::stackSize(oop java_thread) { | |
| 686 // The stackSize field is only present starting in 1.4 | |
| 687 if (_stackSize_offset > 0) { | |
| 688 assert(JDK_Version::is_gte_jdk14x_version(), "sanity check"); | |
| 689 return java_thread->long_field(_stackSize_offset); | |
| 690 } else { | |
| 691 return 0; | |
| 692 } | |
| 693 } | |
| 694 | |
| 695 // Write the thread status value to threadStatus field in java.lang.Thread java class. | |
| 696 void java_lang_Thread::set_thread_status(oop java_thread, | |
| 697 java_lang_Thread::ThreadStatus status) { | |
| 698 assert(JavaThread::current()->thread_state() == _thread_in_vm, "Java Thread is not running in vm"); | |
| 699 // The threadStatus is only present starting in 1.5 | |
| 700 if (_thread_status_offset > 0) { | |
| 701 java_thread->int_field_put(_thread_status_offset, status); | |
| 702 } | |
| 703 } | |
| 704 | |
| 705 // Read thread status value from threadStatus field in java.lang.Thread java class. | |
| 706 java_lang_Thread::ThreadStatus java_lang_Thread::get_thread_status(oop java_thread) { | |
| 707 assert(Thread::current()->is_VM_thread() || | |
| 708 JavaThread::current()->thread_state() == _thread_in_vm, | |
| 709 "Java Thread is not running in vm"); | |
| 710 // The threadStatus is only present starting in 1.5 | |
| 711 if (_thread_status_offset > 0) { | |
| 712 return (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset); | |
| 713 } else { | |
| 714 // All we can easily figure out is if it is alive, but that is | |
| 715 // enough info for a valid unknown status. | |
| 716 // These aren't restricted to valid set ThreadStatus values, so | |
| 717 // use JVMTI values and cast. | |
| 718 JavaThread* thr = java_lang_Thread::thread(java_thread); | |
| 719 if (thr == NULL) { | |
| 720 // the thread hasn't run yet or is in the process of exiting | |
| 721 return NEW; | |
| 722 } | |
| 723 return (java_lang_Thread::ThreadStatus)JVMTI_THREAD_STATE_ALIVE; | |
| 724 } | |
| 725 } | |
| 726 | |
| 727 | |
| 728 jlong java_lang_Thread::thread_id(oop java_thread) { | |
| 729 // The thread ID field is only present starting in 1.5 | |
| 730 if (_tid_offset > 0) { | |
| 731 return java_thread->long_field(_tid_offset); | |
| 732 } else { | |
| 733 return 0; | |
| 734 } | |
| 735 } | |
| 736 | |
| 737 oop java_lang_Thread::park_blocker(oop java_thread) { | |
| 242 | 738 assert(JDK_Version::current().supports_thread_park_blocker() && |
| 739 _park_blocker_offset != 0, "Must support parkBlocker field"); | |
| 0 | 740 |
| 741 if (_park_blocker_offset > 0) { | |
| 742 return java_thread->obj_field(_park_blocker_offset); | |
| 743 } | |
| 744 | |
| 745 return NULL; | |
| 746 } | |
| 747 | |
| 748 jlong java_lang_Thread::park_event(oop java_thread) { | |
| 749 if (_park_event_offset > 0) { | |
| 750 return java_thread->long_field(_park_event_offset); | |
| 751 } | |
| 752 return 0; | |
| 753 } | |
| 754 | |
| 755 bool java_lang_Thread::set_park_event(oop java_thread, jlong ptr) { | |
| 756 if (_park_event_offset > 0) { | |
| 757 java_thread->long_field_put(_park_event_offset, ptr); | |
| 758 return true; | |
| 759 } | |
| 760 return false; | |
| 761 } | |
| 762 | |
| 763 | |
| 764 const char* java_lang_Thread::thread_status_name(oop java_thread) { | |
| 765 assert(JDK_Version::is_gte_jdk15x_version() && _thread_status_offset != 0, "Must have thread status"); | |
| 766 ThreadStatus status = (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset); | |
| 767 switch (status) { | |
| 768 case NEW : return "NEW"; | |
| 769 case RUNNABLE : return "RUNNABLE"; | |
| 770 case SLEEPING : return "TIMED_WAITING (sleeping)"; | |
| 771 case IN_OBJECT_WAIT : return "WAITING (on object monitor)"; | |
| 772 case IN_OBJECT_WAIT_TIMED : return "TIMED_WAITING (on object monitor)"; | |
| 773 case PARKED : return "WAITING (parking)"; | |
| 774 case PARKED_TIMED : return "TIMED_WAITING (parking)"; | |
| 775 case BLOCKED_ON_MONITOR_ENTER : return "BLOCKED (on object monitor)"; | |
| 776 case TERMINATED : return "TERMINATED"; | |
| 777 default : return "UNKNOWN"; | |
| 778 }; | |
| 779 } | |
| 780 int java_lang_ThreadGroup::_parent_offset = 0; | |
| 781 int java_lang_ThreadGroup::_name_offset = 0; | |
| 782 int java_lang_ThreadGroup::_threads_offset = 0; | |
| 783 int java_lang_ThreadGroup::_groups_offset = 0; | |
| 784 int java_lang_ThreadGroup::_maxPriority_offset = 0; | |
| 785 int java_lang_ThreadGroup::_destroyed_offset = 0; | |
| 786 int java_lang_ThreadGroup::_daemon_offset = 0; | |
| 787 int java_lang_ThreadGroup::_vmAllowSuspension_offset = 0; | |
| 788 int java_lang_ThreadGroup::_nthreads_offset = 0; | |
| 789 int java_lang_ThreadGroup::_ngroups_offset = 0; | |
| 790 | |
| 791 oop java_lang_ThreadGroup::parent(oop java_thread_group) { | |
| 792 assert(java_thread_group->is_oop(), "thread group must be oop"); | |
| 793 return java_thread_group->obj_field(_parent_offset); | |
| 794 } | |
| 795 | |
| 796 // ("name as oop" accessor is not necessary) | |
| 797 | |
| 798 typeArrayOop java_lang_ThreadGroup::name(oop java_thread_group) { | |
| 799 oop name = java_thread_group->obj_field(_name_offset); | |
| 800 // ThreadGroup.name can be null | |
| 801 return name == NULL ? (typeArrayOop)NULL : java_lang_String::value(name); | |
| 802 } | |
| 803 | |
| 804 int java_lang_ThreadGroup::nthreads(oop java_thread_group) { | |
| 805 assert(java_thread_group->is_oop(), "thread group must be oop"); | |
| 806 return java_thread_group->int_field(_nthreads_offset); | |
| 807 } | |
| 808 | |
| 809 objArrayOop java_lang_ThreadGroup::threads(oop java_thread_group) { | |
| 810 oop threads = java_thread_group->obj_field(_threads_offset); | |
| 811 assert(threads != NULL, "threadgroups should have threads"); | |
| 812 assert(threads->is_objArray(), "just checking"); // Todo: Add better type checking code | |
| 813 return objArrayOop(threads); | |
| 814 } | |
| 815 | |
| 816 int java_lang_ThreadGroup::ngroups(oop java_thread_group) { | |
| 817 assert(java_thread_group->is_oop(), "thread group must be oop"); | |
| 818 return java_thread_group->int_field(_ngroups_offset); | |
| 819 } | |
| 820 | |
| 821 objArrayOop java_lang_ThreadGroup::groups(oop java_thread_group) { | |
| 822 oop groups = java_thread_group->obj_field(_groups_offset); | |
| 823 assert(groups == NULL || groups->is_objArray(), "just checking"); // Todo: Add better type checking code | |
| 824 return objArrayOop(groups); | |
| 825 } | |
| 826 | |
| 827 ThreadPriority java_lang_ThreadGroup::maxPriority(oop java_thread_group) { | |
| 828 assert(java_thread_group->is_oop(), "thread group must be oop"); | |
| 829 return (ThreadPriority) java_thread_group->int_field(_maxPriority_offset); | |
| 830 } | |
| 831 | |
| 832 bool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) { | |
| 833 assert(java_thread_group->is_oop(), "thread group must be oop"); | |
| 834 return java_thread_group->bool_field(_destroyed_offset) != 0; | |
| 835 } | |
| 836 | |
| 837 bool java_lang_ThreadGroup::is_daemon(oop java_thread_group) { | |
| 838 assert(java_thread_group->is_oop(), "thread group must be oop"); | |
| 839 return java_thread_group->bool_field(_daemon_offset) != 0; | |
| 840 } | |
| 841 | |
| 842 bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) { | |
| 843 assert(java_thread_group->is_oop(), "thread group must be oop"); | |
| 844 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0; | |
| 845 } | |
| 846 | |
| 847 void java_lang_ThreadGroup::compute_offsets() { | |
| 848 assert(_parent_offset == 0, "offsets should be initialized only once"); | |
| 849 | |
| 850 klassOop k = SystemDictionary::threadGroup_klass(); | |
| 851 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
852 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
853 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
854 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
855 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
856 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
857 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
858 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
859 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
860 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
861 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature()); |
| 0 | 862 } |
| 863 | |
| 864 oop java_lang_Throwable::backtrace(oop throwable) { | |
| 865 return throwable->obj_field_acquire(backtrace_offset); | |
| 866 } | |
| 867 | |
| 868 | |
| 869 void java_lang_Throwable::set_backtrace(oop throwable, oop value) { | |
| 870 throwable->release_obj_field_put(backtrace_offset, value); | |
| 871 } | |
| 872 | |
| 873 | |
| 874 oop java_lang_Throwable::message(oop throwable) { | |
| 875 return throwable->obj_field(detailMessage_offset); | |
| 876 } | |
| 877 | |
| 878 | |
| 879 oop java_lang_Throwable::message(Handle throwable) { | |
| 880 return throwable->obj_field(detailMessage_offset); | |
| 881 } | |
| 882 | |
| 883 | |
| 884 void java_lang_Throwable::set_message(oop throwable, oop value) { | |
| 885 throwable->obj_field_put(detailMessage_offset, value); | |
| 886 } | |
| 887 | |
| 888 | |
| 889 void java_lang_Throwable::clear_stacktrace(oop throwable) { | |
| 890 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); | |
| 891 throwable->obj_field_put(stackTrace_offset, NULL); | |
| 892 } | |
| 893 | |
| 894 | |
| 895 void java_lang_Throwable::print(oop throwable, outputStream* st) { | |
| 896 ResourceMark rm; | |
| 897 klassOop k = throwable->klass(); | |
| 898 assert(k != NULL, "just checking"); | |
| 899 st->print("%s", instanceKlass::cast(k)->external_name()); | |
| 900 oop msg = message(throwable); | |
| 901 if (msg != NULL) { | |
| 902 st->print(": %s", java_lang_String::as_utf8_string(msg)); | |
| 903 } | |
| 904 } | |
| 905 | |
| 906 | |
| 907 void java_lang_Throwable::print(Handle throwable, outputStream* st) { | |
| 908 ResourceMark rm; | |
| 909 klassOop k = throwable->klass(); | |
| 910 assert(k != NULL, "just checking"); | |
| 911 st->print("%s", instanceKlass::cast(k)->external_name()); | |
| 912 oop msg = message(throwable); | |
| 913 if (msg != NULL) { | |
| 914 st->print(": %s", java_lang_String::as_utf8_string(msg)); | |
| 915 } | |
| 916 } | |
| 917 | |
| 918 // Print stack trace element to resource allocated buffer | |
| 919 char* java_lang_Throwable::print_stack_element_to_buffer(methodOop method, int bci) { | |
| 920 // Get strings and string lengths | |
| 921 instanceKlass* klass = instanceKlass::cast(method->method_holder()); | |
| 922 const char* klass_name = klass->external_name(); | |
| 923 int buf_len = (int)strlen(klass_name); | |
| 924 char* source_file_name; | |
| 925 if (klass->source_file_name() == NULL) { | |
| 926 source_file_name = NULL; | |
| 927 } else { | |
| 928 source_file_name = klass->source_file_name()->as_C_string(); | |
| 929 buf_len += (int)strlen(source_file_name); | |
| 930 } | |
| 931 char* method_name = method->name()->as_C_string(); | |
| 932 buf_len += (int)strlen(method_name); | |
| 933 | |
| 934 // Allocate temporary buffer with extra space for formatting and line number | |
| 935 char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64); | |
| 936 | |
| 937 // Print stack trace line in buffer | |
| 938 sprintf(buf, "\tat %s.%s", klass_name, method_name); | |
| 939 if (method->is_native()) { | |
| 940 strcat(buf, "(Native Method)"); | |
| 941 } else { | |
| 942 int line_number = method->line_number_from_bci(bci); | |
| 943 if (source_file_name != NULL && (line_number != -1)) { | |
| 944 // Sourcename and linenumber | |
| 945 sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number); | |
| 946 } else if (source_file_name != NULL) { | |
| 947 // Just sourcename | |
| 948 sprintf(buf + (int)strlen(buf), "(%s)", source_file_name); | |
| 949 } else { | |
| 950 // Neither soucename and linenumber | |
| 951 sprintf(buf + (int)strlen(buf), "(Unknown Source)"); | |
| 952 } | |
| 953 nmethod* nm = method->code(); | |
| 954 if (WizardMode && nm != NULL) { | |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
242
diff
changeset
|
955 sprintf(buf + (int)strlen(buf), "(nmethod " PTR_FORMAT ")", (intptr_t)nm); |
| 0 | 956 } |
| 957 } | |
| 958 | |
| 959 return buf; | |
| 960 } | |
| 961 | |
| 962 | |
| 963 void java_lang_Throwable::print_stack_element(Handle stream, methodOop method, int bci) { | |
| 964 ResourceMark rm; | |
| 965 char* buf = print_stack_element_to_buffer(method, bci); | |
| 966 print_to_stream(stream, buf); | |
| 967 } | |
| 968 | |
| 969 void java_lang_Throwable::print_stack_element(outputStream *st, methodOop method, int bci) { | |
| 970 ResourceMark rm; | |
| 971 char* buf = print_stack_element_to_buffer(method, bci); | |
| 972 st->print_cr("%s", buf); | |
| 973 } | |
| 974 | |
| 975 void java_lang_Throwable::print_to_stream(Handle stream, const char* str) { | |
| 976 if (stream.is_null()) { | |
| 977 tty->print_cr("%s", str); | |
| 978 } else { | |
| 979 EXCEPTION_MARK; | |
| 980 JavaValue result(T_VOID); | |
| 981 Handle arg (THREAD, oopFactory::new_charArray(str, THREAD)); | |
| 982 if (!HAS_PENDING_EXCEPTION) { | |
| 983 JavaCalls::call_virtual(&result, | |
| 984 stream, | |
| 985 KlassHandle(THREAD, stream->klass()), | |
| 986 vmSymbolHandles::println_name(), | |
| 987 vmSymbolHandles::char_array_void_signature(), | |
| 988 arg, | |
| 989 THREAD); | |
| 990 } | |
| 991 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM. | |
| 992 if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION; | |
| 993 } | |
| 994 | |
| 995 } | |
| 996 | |
| 997 | |
| 998 const char* java_lang_Throwable::no_stack_trace_message() { | |
| 999 return "\t<<no stack trace available>>"; | |
| 1000 } | |
| 1001 | |
| 1002 | |
| 1003 // Currently used only for exceptions occurring during startup | |
| 1004 void java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) { | |
| 1005 Thread *THREAD = Thread::current(); | |
| 1006 Handle h_throwable(THREAD, throwable); | |
| 1007 while (h_throwable.not_null()) { | |
| 1008 objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable()))); | |
| 1009 if (result.is_null()) { | |
| 1010 st->print_cr(no_stack_trace_message()); | |
| 1011 return; | |
| 1012 } | |
| 1013 | |
| 1014 while (result.not_null()) { | |
| 1015 objArrayHandle methods (THREAD, | |
| 1016 objArrayOop(result->obj_at(trace_methods_offset))); | |
| 1017 typeArrayHandle bcis (THREAD, | |
| 1018 typeArrayOop(result->obj_at(trace_bcis_offset))); | |
| 1019 | |
| 1020 if (methods.is_null() || bcis.is_null()) { | |
| 1021 st->print_cr(no_stack_trace_message()); | |
| 1022 return; | |
| 1023 } | |
| 1024 | |
| 1025 int length = methods()->length(); | |
| 1026 for (int index = 0; index < length; index++) { | |
| 1027 methodOop method = methodOop(methods()->obj_at(index)); | |
| 1028 if (method == NULL) goto handle_cause; | |
| 1029 int bci = bcis->ushort_at(index); | |
| 1030 print_stack_element(st, method, bci); | |
| 1031 } | |
| 1032 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset))); | |
| 1033 } | |
| 1034 handle_cause: | |
| 1035 { | |
| 1036 EXCEPTION_MARK; | |
| 1037 JavaValue result(T_OBJECT); | |
| 1038 JavaCalls::call_virtual(&result, | |
| 1039 h_throwable, | |
| 1040 KlassHandle(THREAD, h_throwable->klass()), | |
| 1041 vmSymbolHandles::getCause_name(), | |
| 1042 vmSymbolHandles::void_throwable_signature(), | |
| 1043 THREAD); | |
| 1044 // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM. | |
| 1045 if (HAS_PENDING_EXCEPTION) { | |
| 1046 CLEAR_PENDING_EXCEPTION; | |
| 1047 h_throwable = Handle(); | |
| 1048 } else { | |
| 1049 h_throwable = Handle(THREAD, (oop) result.get_jobject()); | |
| 1050 if (h_throwable.not_null()) { | |
| 1051 st->print("Caused by: "); | |
| 1052 print(h_throwable, st); | |
| 1053 st->cr(); | |
| 1054 } | |
| 1055 } | |
| 1056 } | |
| 1057 } | |
| 1058 } | |
| 1059 | |
| 1060 | |
| 1061 void java_lang_Throwable::print_stack_trace(oop throwable, oop print_stream) { | |
| 1062 // Note: this is no longer used in Merlin, but we support it for compatibility. | |
| 1063 Thread *thread = Thread::current(); | |
| 1064 Handle stream(thread, print_stream); | |
| 1065 objArrayHandle result (thread, objArrayOop(backtrace(throwable))); | |
| 1066 if (result.is_null()) { | |
| 1067 print_to_stream(stream, no_stack_trace_message()); | |
| 1068 return; | |
| 1069 } | |
| 1070 | |
| 1071 while (result.not_null()) { | |
| 1072 objArrayHandle methods (thread, | |
| 1073 objArrayOop(result->obj_at(trace_methods_offset))); | |
| 1074 typeArrayHandle bcis (thread, | |
| 1075 typeArrayOop(result->obj_at(trace_bcis_offset))); | |
| 1076 | |
| 1077 if (methods.is_null() || bcis.is_null()) { | |
| 1078 print_to_stream(stream, no_stack_trace_message()); | |
| 1079 return; | |
| 1080 } | |
| 1081 | |
| 1082 int length = methods()->length(); | |
| 1083 for (int index = 0; index < length; index++) { | |
| 1084 methodOop method = methodOop(methods()->obj_at(index)); | |
| 1085 if (method == NULL) return; | |
| 1086 int bci = bcis->ushort_at(index); | |
| 1087 print_stack_element(stream, method, bci); | |
| 1088 } | |
| 1089 result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset))); | |
| 1090 } | |
| 1091 } | |
| 1092 | |
| 1093 // This class provides a simple wrapper over the internal structure of | |
| 1094 // exception backtrace to insulate users of the backtrace from needing | |
| 1095 // to know what it looks like. | |
| 1096 class BacktraceBuilder: public StackObj { | |
| 1097 private: | |
| 1098 Handle _backtrace; | |
| 1099 objArrayOop _head; | |
| 1100 objArrayOop _methods; | |
| 1101 typeArrayOop _bcis; | |
| 1102 int _index; | |
| 1103 bool _dirty; | |
| 1104 No_Safepoint_Verifier _nsv; | |
| 1105 | |
| 1106 public: | |
| 1107 | |
| 1108 enum { | |
| 1109 trace_methods_offset = java_lang_Throwable::trace_methods_offset, | |
| 1110 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset, | |
| 1111 trace_next_offset = java_lang_Throwable::trace_next_offset, | |
| 1112 trace_size = java_lang_Throwable::trace_size, | |
| 1113 trace_chunk_size = java_lang_Throwable::trace_chunk_size | |
| 1114 }; | |
| 1115 | |
| 1116 // constructor for new backtrace | |
|
98
deb97b8ef02b
6679708: No_Safepoint_Verifier and BacktraceBuilder have uninitialized fields
never
parents:
22
diff
changeset
|
1117 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _dirty(false) { |
| 0 | 1118 expand(CHECK); |
| 1119 _backtrace = _head; | |
| 1120 _index = 0; | |
| 1121 } | |
| 1122 | |
| 1123 void flush() { | |
| 1124 if (_dirty && _methods != NULL) { | |
| 1125 BarrierSet* bs = Universe::heap()->barrier_set(); | |
| 1126 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); | |
|
1091
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
949
diff
changeset
|
1127 bs->write_ref_array((HeapWord*)_methods->base(), _methods->length()); |
| 0 | 1128 _dirty = false; |
| 1129 } | |
| 1130 } | |
| 1131 | |
| 1132 void expand(TRAPS) { | |
| 1133 flush(); | |
| 1134 | |
| 1135 objArrayHandle old_head(THREAD, _head); | |
| 1136 Pause_No_Safepoint_Verifier pnsv(&_nsv); | |
| 1137 | |
| 1138 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK); | |
| 1139 objArrayHandle new_head(THREAD, head); | |
| 1140 | |
| 1141 objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK); | |
| 1142 objArrayHandle new_methods(THREAD, methods); | |
| 1143 | |
| 1144 typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK); | |
| 1145 typeArrayHandle new_bcis(THREAD, bcis); | |
| 1146 | |
| 1147 if (!old_head.is_null()) { | |
| 1148 old_head->obj_at_put(trace_next_offset, new_head()); | |
| 1149 } | |
| 1150 new_head->obj_at_put(trace_methods_offset, new_methods()); | |
| 1151 new_head->obj_at_put(trace_bcis_offset, new_bcis()); | |
| 1152 | |
| 1153 _head = new_head(); | |
| 1154 _methods = new_methods(); | |
| 1155 _bcis = new_bcis(); | |
| 1156 _index = 0; | |
| 1157 } | |
| 1158 | |
| 1159 oop backtrace() { | |
| 1160 flush(); | |
| 1161 return _backtrace(); | |
| 1162 } | |
| 1163 | |
| 1164 inline void push(methodOop method, short bci, TRAPS) { | |
| 1165 if (_index >= trace_chunk_size) { | |
| 1166 methodHandle mhandle(THREAD, method); | |
| 1167 expand(CHECK); | |
| 1168 method = mhandle(); | |
| 1169 } | |
| 1170 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
1171 _methods->obj_at_put(_index, method); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
1172 // bad for UseCompressedOops |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
1173 // *_methods->obj_at_addr(_index) = method; |
| 0 | 1174 _bcis->ushort_at_put(_index, bci); |
| 1175 _index++; | |
| 1176 _dirty = true; | |
| 1177 } | |
| 1178 | |
| 1179 methodOop current_method() { | |
| 1180 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); | |
| 1181 return methodOop(_methods->obj_at(_index)); | |
| 1182 } | |
| 1183 | |
| 1184 jushort current_bci() { | |
| 1185 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); | |
| 1186 return _bcis->ushort_at(_index); | |
| 1187 } | |
| 1188 }; | |
| 1189 | |
| 1190 | |
| 1191 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, TRAPS) { | |
| 1192 if (!StackTraceInThrowable) return; | |
| 1193 ResourceMark rm(THREAD); | |
| 1194 | |
| 1195 // Start out by clearing the backtrace for this object, in case the VM | |
| 1196 // runs out of memory while allocating the stack trace | |
| 1197 set_backtrace(throwable(), NULL); | |
| 1198 if (JDK_Version::is_gte_jdk14x_version()) { | |
| 1199 // New since 1.4, clear lazily constructed Java level stacktrace if | |
| 1200 // refilling occurs | |
| 1201 clear_stacktrace(throwable()); | |
| 1202 } | |
| 1203 | |
| 1204 int max_depth = MaxJavaStackTraceDepth; | |
| 1205 JavaThread* thread = (JavaThread*)THREAD; | |
| 1206 BacktraceBuilder bt(CHECK); | |
| 1207 | |
| 1208 // Instead of using vframe directly, this version of fill_in_stack_trace | |
| 1209 // basically handles everything by hand. This significantly improved the | |
| 1210 // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows. | |
| 1211 // See bug 6333838 for more details. | |
| 1212 // The "ASSERT" here is to verify this method generates the exactly same stack | |
| 1213 // trace as utilizing vframe. | |
| 1214 #ifdef ASSERT | |
| 1215 vframeStream st(thread); | |
| 1216 methodHandle st_method(THREAD, st.method()); | |
| 1217 #endif | |
| 1218 int total_count = 0; | |
| 1219 RegisterMap map(thread, false); | |
| 1220 int decode_offset = 0; | |
| 1221 nmethod* nm = NULL; | |
| 1222 bool skip_fillInStackTrace_check = false; | |
| 1223 bool skip_throwableInit_check = false; | |
| 1224 | |
| 1225 for (frame fr = thread->last_frame(); max_depth != total_count;) { | |
| 1226 methodOop method = NULL; | |
| 1227 int bci = 0; | |
| 1228 | |
| 1229 // Compiled java method case. | |
| 1230 if (decode_offset != 0) { | |
| 1231 DebugInfoReadStream stream(nm, decode_offset); | |
| 1232 decode_offset = stream.read_int(); | |
| 1233 method = (methodOop)nm->oop_at(stream.read_int()); | |
|
931
72088be4b386
6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents:
900
diff
changeset
|
1234 bci = stream.read_bci(); |
| 0 | 1235 } else { |
| 1236 if (fr.is_first_frame()) break; | |
| 1237 address pc = fr.pc(); | |
| 1238 if (fr.is_interpreted_frame()) { | |
| 1239 intptr_t bcx = fr.interpreter_frame_bcx(); | |
| 1240 method = fr.interpreter_frame_method(); | |
| 1241 bci = fr.is_bci(bcx) ? bcx : method->bci_from((address)bcx); | |
| 1242 fr = fr.sender(&map); | |
| 1243 } else { | |
| 1244 CodeBlob* cb = fr.cb(); | |
| 1245 // HMMM QQQ might be nice to have frame return nm as NULL if cb is non-NULL | |
| 1246 // but non nmethod | |
| 1247 fr = fr.sender(&map); | |
| 1248 if (cb == NULL || !cb->is_nmethod()) { | |
| 1249 continue; | |
| 1250 } | |
| 1251 nm = (nmethod*)cb; | |
| 1252 if (nm->method()->is_native()) { | |
| 1253 method = nm->method(); | |
| 1254 bci = 0; | |
| 1255 } else { | |
| 1256 PcDesc* pd = nm->pc_desc_at(pc); | |
| 1257 decode_offset = pd->scope_decode_offset(); | |
| 1258 // if decode_offset is not equal to 0, it will execute the | |
| 1259 // "compiled java method case" at the beginning of the loop. | |
| 1260 continue; | |
| 1261 } | |
| 1262 } | |
| 1263 } | |
| 1264 #ifdef ASSERT | |
| 1265 assert(st_method() == method && st.bci() == bci, | |
| 1266 "Wrong stack trace"); | |
| 1267 st.next(); | |
| 1268 // vframeStream::method isn't GC-safe so store off a copy | |
| 1269 // of the methodOop in case we GC. | |
| 1270 if (!st.at_end()) { | |
| 1271 st_method = st.method(); | |
| 1272 } | |
| 1273 #endif | |
| 1274 if (!skip_fillInStackTrace_check) { | |
| 1275 // check "fillInStackTrace" only once, so we negate the flag | |
| 1276 // after the first time check. | |
| 1277 skip_fillInStackTrace_check = true; | |
| 1278 if (method->name() == vmSymbols::fillInStackTrace_name()) { | |
| 1279 continue; | |
| 1280 } | |
| 1281 } | |
| 1282 // skip <init> methods of the exceptions klass. If there is <init> methods | |
| 1283 // that belongs to a superclass of the exception we are going to skipping | |
| 1284 // them in stack trace. This is simlar to classic VM. | |
| 1285 if (!skip_throwableInit_check) { | |
| 1286 if (method->name() == vmSymbols::object_initializer_name() && | |
| 1287 throwable->is_a(method->method_holder())) { | |
| 1288 continue; | |
| 1289 } else { | |
| 1290 // if no "Throwable.init()" method found, we stop checking it next time. | |
| 1291 skip_throwableInit_check = true; | |
| 1292 } | |
| 1293 } | |
| 1294 bt.push(method, bci, CHECK); | |
| 1295 total_count++; | |
| 1296 } | |
| 1297 | |
| 1298 // Put completed stack trace into throwable object | |
| 1299 set_backtrace(throwable(), bt.backtrace()); | |
| 1300 } | |
| 1301 | |
| 1302 void java_lang_Throwable::fill_in_stack_trace(Handle throwable) { | |
| 1303 // No-op if stack trace is disabled | |
| 1304 if (!StackTraceInThrowable) { | |
| 1305 return; | |
| 1306 } | |
| 1307 | |
| 1308 // Disable stack traces for some preallocated out of memory errors | |
| 1309 if (!Universe::should_fill_in_stack_trace(throwable)) { | |
| 1310 return; | |
| 1311 } | |
| 1312 | |
| 1313 PRESERVE_EXCEPTION_MARK; | |
| 1314 | |
| 1315 JavaThread* thread = JavaThread::active(); | |
| 1316 fill_in_stack_trace(throwable, thread); | |
| 1317 // ignore exceptions thrown during stack trace filling | |
| 1318 CLEAR_PENDING_EXCEPTION; | |
| 1319 } | |
| 1320 | |
| 1321 void java_lang_Throwable::allocate_backtrace(Handle throwable, TRAPS) { | |
| 1322 // Allocate stack trace - backtrace is created but not filled in | |
| 1323 | |
| 1324 // No-op if stack trace is disabled | |
| 1325 if (!StackTraceInThrowable) return; | |
| 1326 | |
| 1327 objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK); | |
| 1328 objArrayHandle backtrace (THREAD, h_oop); | |
| 1329 objArrayOop m_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK); | |
| 1330 objArrayHandle methods (THREAD, m_oop); | |
| 1331 typeArrayOop b = oopFactory::new_shortArray(trace_chunk_size, CHECK); | |
| 1332 typeArrayHandle bcis(THREAD, b); | |
| 1333 | |
| 1334 // backtrace has space for one chunk (next is NULL) | |
| 1335 backtrace->obj_at_put(trace_methods_offset, methods()); | |
| 1336 backtrace->obj_at_put(trace_bcis_offset, bcis()); | |
| 1337 set_backtrace(throwable(), backtrace()); | |
| 1338 } | |
| 1339 | |
| 1340 | |
| 1341 void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) { | |
| 1342 // Fill in stack trace into preallocated backtrace (no GC) | |
| 1343 | |
| 1344 // No-op if stack trace is disabled | |
| 1345 if (!StackTraceInThrowable) return; | |
| 1346 | |
| 1347 assert(throwable->is_a(SystemDictionary::throwable_klass()), "sanity check"); | |
| 1348 | |
| 1349 oop backtrace = java_lang_Throwable::backtrace(throwable()); | |
| 1350 assert(backtrace != NULL, "backtrace not preallocated"); | |
| 1351 | |
| 1352 oop m = objArrayOop(backtrace)->obj_at(trace_methods_offset); | |
| 1353 objArrayOop methods = objArrayOop(m); | |
| 1354 assert(methods != NULL && methods->length() > 0, "method array not preallocated"); | |
| 1355 | |
| 1356 oop b = objArrayOop(backtrace)->obj_at(trace_bcis_offset); | |
| 1357 typeArrayOop bcis = typeArrayOop(b); | |
| 1358 assert(bcis != NULL, "bci array not preallocated"); | |
| 1359 | |
| 1360 assert(methods->length() == bcis->length(), "method and bci arrays should match"); | |
| 1361 | |
| 1362 JavaThread* thread = JavaThread::current(); | |
| 1363 ResourceMark rm(thread); | |
| 1364 vframeStream st(thread); | |
| 1365 | |
| 1366 // Unlike fill_in_stack_trace we do not skip fillInStackTrace or throwable init | |
| 1367 // methods as preallocated errors aren't created by "java" code. | |
| 1368 | |
| 1369 // fill in as much stack trace as possible | |
| 1370 int max_chunks = MIN2(methods->length(), (int)MaxJavaStackTraceDepth); | |
| 1371 int chunk_count = 0; | |
| 1372 | |
| 1373 for (;!st.at_end(); st.next()) { | |
| 1374 // add element | |
| 1375 bcis->ushort_at_put(chunk_count, st.bci()); | |
| 1376 methods->obj_at_put(chunk_count, st.method()); | |
| 1377 | |
| 1378 chunk_count++; | |
| 1379 | |
| 1380 // Bail-out for deep stacks | |
| 1381 if (chunk_count >= max_chunks) break; | |
| 1382 } | |
| 1383 } | |
| 1384 | |
| 1385 | |
| 1386 int java_lang_Throwable::get_stack_trace_depth(oop throwable, TRAPS) { | |
| 1387 if (throwable == NULL) { | |
| 1388 THROW_0(vmSymbols::java_lang_NullPointerException()); | |
| 1389 } | |
| 1390 objArrayOop chunk = objArrayOop(backtrace(throwable)); | |
| 1391 int depth = 0; | |
| 1392 if (chunk != NULL) { | |
| 1393 // Iterate over chunks and count full ones | |
| 1394 while (true) { | |
| 1395 objArrayOop next = objArrayOop(chunk->obj_at(trace_next_offset)); | |
| 1396 if (next == NULL) break; | |
| 1397 depth += trace_chunk_size; | |
| 1398 chunk = next; | |
| 1399 } | |
| 1400 assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check"); | |
| 1401 // Count element in remaining partial chunk | |
| 1402 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); | |
| 1403 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); | |
| 1404 assert(methods != NULL && bcis != NULL, "sanity check"); | |
| 1405 for (int i = 0; i < methods->length(); i++) { | |
| 1406 if (methods->obj_at(i) == NULL) break; | |
| 1407 depth++; | |
| 1408 } | |
| 1409 } | |
| 1410 return depth; | |
| 1411 } | |
| 1412 | |
| 1413 | |
| 1414 oop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) { | |
| 1415 if (throwable == NULL) { | |
| 1416 THROW_0(vmSymbols::java_lang_NullPointerException()); | |
| 1417 } | |
| 1418 if (index < 0) { | |
| 1419 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); | |
| 1420 } | |
| 1421 // Compute how many chunks to skip and index into actual chunk | |
| 1422 objArrayOop chunk = objArrayOop(backtrace(throwable)); | |
| 1423 int skip_chunks = index / trace_chunk_size; | |
| 1424 int chunk_index = index % trace_chunk_size; | |
| 1425 while (chunk != NULL && skip_chunks > 0) { | |
| 1426 chunk = objArrayOop(chunk->obj_at(trace_next_offset)); | |
| 1427 skip_chunks--; | |
| 1428 } | |
| 1429 if (chunk == NULL) { | |
| 1430 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); | |
| 1431 } | |
| 1432 // Get method,bci from chunk | |
| 1433 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); | |
| 1434 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); | |
| 1435 assert(methods != NULL && bcis != NULL, "sanity check"); | |
| 1436 methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index))); | |
| 1437 int bci = bcis->ushort_at(chunk_index); | |
| 1438 // Chunk can be partial full | |
| 1439 if (method.is_null()) { | |
| 1440 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); | |
| 1441 } | |
| 1442 | |
| 1443 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_0); | |
| 1444 return element; | |
| 1445 } | |
| 1446 | |
| 1447 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) { | |
| 1448 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs | |
| 1449 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); | |
| 1450 | |
| 1451 // Allocate java.lang.StackTraceElement instance | |
| 1452 klassOop k = SystemDictionary::stackTraceElement_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1453 assert(k != NULL, "must be loaded in 1.4+"); |
| 0 | 1454 instanceKlassHandle ik (THREAD, k); |
| 1455 if (ik->should_be_initialized()) { | |
| 1456 ik->initialize(CHECK_0); | |
| 1457 } | |
| 1458 | |
| 1459 Handle element = ik->allocate_instance_handle(CHECK_0); | |
| 1460 // Fill in class name | |
| 1461 ResourceMark rm(THREAD); | |
| 1462 const char* str = instanceKlass::cast(method->method_holder())->external_name(); | |
| 1463 oop classname = StringTable::intern((char*) str, CHECK_0); | |
| 1464 java_lang_StackTraceElement::set_declaringClass(element(), classname); | |
| 1465 // Fill in method name | |
| 1466 oop methodname = StringTable::intern(method->name(), CHECK_0); | |
| 1467 java_lang_StackTraceElement::set_methodName(element(), methodname); | |
| 1468 // Fill in source file name | |
| 1469 symbolOop source = instanceKlass::cast(method->method_holder())->source_file_name(); | |
| 1470 oop filename = StringTable::intern(source, CHECK_0); | |
| 1471 java_lang_StackTraceElement::set_fileName(element(), filename); | |
| 1472 // File in source line number | |
| 1473 int line_number; | |
| 1474 if (method->is_native()) { | |
| 1475 // Negative value different from -1 below, enabling Java code in | |
| 1476 // class java.lang.StackTraceElement to distinguish "native" from | |
| 1477 // "no LineNumberTable". | |
| 1478 line_number = -2; | |
| 1479 } else { | |
| 1480 // Returns -1 if no LineNumberTable, and otherwise actual line number | |
| 1481 line_number = method->line_number_from_bci(bci); | |
| 1482 } | |
| 1483 java_lang_StackTraceElement::set_lineNumber(element(), line_number); | |
| 1484 | |
| 1485 return element(); | |
| 1486 } | |
| 1487 | |
| 1488 | |
| 1489 void java_lang_reflect_AccessibleObject::compute_offsets() { | |
| 1490 klassOop k = SystemDictionary::reflect_accessible_object_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1491 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); |
| 0 | 1492 } |
| 1493 | |
| 1494 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { | |
| 1495 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1496 return (jboolean) reflect->bool_field(override_offset); | |
| 1497 } | |
| 1498 | |
| 1499 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) { | |
| 1500 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1501 reflect->bool_field_put(override_offset, (int) value); | |
| 1502 } | |
| 1503 | |
| 1504 void java_lang_reflect_Method::compute_offsets() { | |
| 1505 klassOop k = SystemDictionary::reflect_method_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1506 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1507 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1508 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1509 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1510 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1511 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1512 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
| 0 | 1513 // The generic signature and annotations fields are only present in 1.5 |
| 1514 signature_offset = -1; | |
| 1515 annotations_offset = -1; | |
| 1516 parameter_annotations_offset = -1; | |
| 1517 annotation_default_offset = -1; | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1518 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1519 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1520 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1521 compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature()); |
| 0 | 1522 } |
| 1523 | |
| 1524 Handle java_lang_reflect_Method::create(TRAPS) { | |
| 1525 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1526 klassOop klass = SystemDictionary::reflect_method_klass(); | |
| 1527 // This class is eagerly initialized during VM initialization, since we keep a refence | |
| 1528 // to one of the methods | |
| 1529 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized"); | |
| 1530 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH); | |
| 1531 } | |
| 1532 | |
| 1533 oop java_lang_reflect_Method::clazz(oop reflect) { | |
| 1534 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1535 return reflect->obj_field(clazz_offset); | |
| 1536 } | |
| 1537 | |
| 1538 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) { | |
| 1539 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1540 reflect->obj_field_put(clazz_offset, value); | |
| 1541 } | |
| 1542 | |
| 1543 int java_lang_reflect_Method::slot(oop reflect) { | |
| 1544 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1545 return reflect->int_field(slot_offset); | |
| 1546 } | |
| 1547 | |
| 1548 void java_lang_reflect_Method::set_slot(oop reflect, int value) { | |
| 1549 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1550 reflect->int_field_put(slot_offset, value); | |
| 1551 } | |
| 1552 | |
| 1553 oop java_lang_reflect_Method::name(oop method) { | |
| 1554 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1555 return method->obj_field(name_offset); | |
| 1556 } | |
| 1557 | |
| 1558 void java_lang_reflect_Method::set_name(oop method, oop value) { | |
| 1559 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1560 method->obj_field_put(name_offset, value); | |
| 1561 } | |
| 1562 | |
| 1563 oop java_lang_reflect_Method::return_type(oop method) { | |
| 1564 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1565 return method->obj_field(returnType_offset); | |
| 1566 } | |
| 1567 | |
| 1568 void java_lang_reflect_Method::set_return_type(oop method, oop value) { | |
| 1569 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1570 method->obj_field_put(returnType_offset, value); | |
| 1571 } | |
| 1572 | |
| 1573 oop java_lang_reflect_Method::parameter_types(oop method) { | |
| 1574 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1575 return method->obj_field(parameterTypes_offset); | |
| 1576 } | |
| 1577 | |
| 1578 void java_lang_reflect_Method::set_parameter_types(oop method, oop value) { | |
| 1579 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1580 method->obj_field_put(parameterTypes_offset, value); | |
| 1581 } | |
| 1582 | |
| 1583 oop java_lang_reflect_Method::exception_types(oop method) { | |
| 1584 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1585 return method->obj_field(exceptionTypes_offset); | |
| 1586 } | |
| 1587 | |
| 1588 void java_lang_reflect_Method::set_exception_types(oop method, oop value) { | |
| 1589 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1590 method->obj_field_put(exceptionTypes_offset, value); | |
| 1591 } | |
| 1592 | |
| 1593 int java_lang_reflect_Method::modifiers(oop method) { | |
| 1594 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1595 return method->int_field(modifiers_offset); | |
| 1596 } | |
| 1597 | |
| 1598 void java_lang_reflect_Method::set_modifiers(oop method, int value) { | |
| 1599 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1600 method->int_field_put(modifiers_offset, value); | |
| 1601 } | |
| 1602 | |
| 1603 bool java_lang_reflect_Method::has_signature_field() { | |
| 1604 return (signature_offset >= 0); | |
| 1605 } | |
| 1606 | |
| 1607 oop java_lang_reflect_Method::signature(oop method) { | |
| 1608 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1609 assert(has_signature_field(), "signature field must be present"); | |
| 1610 return method->obj_field(signature_offset); | |
| 1611 } | |
| 1612 | |
| 1613 void java_lang_reflect_Method::set_signature(oop method, oop value) { | |
| 1614 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1615 assert(has_signature_field(), "signature field must be present"); | |
| 1616 method->obj_field_put(signature_offset, value); | |
| 1617 } | |
| 1618 | |
| 1619 bool java_lang_reflect_Method::has_annotations_field() { | |
| 1620 return (annotations_offset >= 0); | |
| 1621 } | |
| 1622 | |
| 1623 oop java_lang_reflect_Method::annotations(oop method) { | |
| 1624 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1625 assert(has_annotations_field(), "annotations field must be present"); | |
| 1626 return method->obj_field(annotations_offset); | |
| 1627 } | |
| 1628 | |
| 1629 void java_lang_reflect_Method::set_annotations(oop method, oop value) { | |
| 1630 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1631 assert(has_annotations_field(), "annotations field must be present"); | |
| 1632 method->obj_field_put(annotations_offset, value); | |
| 1633 } | |
| 1634 | |
| 1635 bool java_lang_reflect_Method::has_parameter_annotations_field() { | |
| 1636 return (parameter_annotations_offset >= 0); | |
| 1637 } | |
| 1638 | |
| 1639 oop java_lang_reflect_Method::parameter_annotations(oop method) { | |
| 1640 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1641 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); | |
| 1642 return method->obj_field(parameter_annotations_offset); | |
| 1643 } | |
| 1644 | |
| 1645 void java_lang_reflect_Method::set_parameter_annotations(oop method, oop value) { | |
| 1646 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1647 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); | |
| 1648 method->obj_field_put(parameter_annotations_offset, value); | |
| 1649 } | |
| 1650 | |
| 1651 bool java_lang_reflect_Method::has_annotation_default_field() { | |
| 1652 return (annotation_default_offset >= 0); | |
| 1653 } | |
| 1654 | |
| 1655 oop java_lang_reflect_Method::annotation_default(oop method) { | |
| 1656 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1657 assert(has_annotation_default_field(), "annotation default field must be present"); | |
| 1658 return method->obj_field(annotation_default_offset); | |
| 1659 } | |
| 1660 | |
| 1661 void java_lang_reflect_Method::set_annotation_default(oop method, oop value) { | |
| 1662 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1663 assert(has_annotation_default_field(), "annotation default field must be present"); | |
| 1664 method->obj_field_put(annotation_default_offset, value); | |
| 1665 } | |
| 1666 | |
| 1667 void java_lang_reflect_Constructor::compute_offsets() { | |
| 1668 klassOop k = SystemDictionary::reflect_constructor_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1669 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1670 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1671 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1672 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1673 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
| 0 | 1674 // The generic signature and annotations fields are only present in 1.5 |
| 1675 signature_offset = -1; | |
| 1676 annotations_offset = -1; | |
| 1677 parameter_annotations_offset = -1; | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1678 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1679 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1680 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); |
| 0 | 1681 } |
| 1682 | |
| 1683 Handle java_lang_reflect_Constructor::create(TRAPS) { | |
| 1684 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1685 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor(); | |
| 1686 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); | |
| 1687 instanceKlassHandle klass (THREAD, k); | |
| 1688 // Ensure it is initialized | |
| 1689 klass->initialize(CHECK_NH); | |
| 1690 return klass->allocate_instance_handle(CHECK_NH); | |
| 1691 } | |
| 1692 | |
| 1693 oop java_lang_reflect_Constructor::clazz(oop reflect) { | |
| 1694 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1695 return reflect->obj_field(clazz_offset); | |
| 1696 } | |
| 1697 | |
| 1698 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) { | |
| 1699 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1700 reflect->obj_field_put(clazz_offset, value); | |
| 1701 } | |
| 1702 | |
| 1703 oop java_lang_reflect_Constructor::parameter_types(oop constructor) { | |
| 1704 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1705 return constructor->obj_field(parameterTypes_offset); | |
| 1706 } | |
| 1707 | |
| 1708 void java_lang_reflect_Constructor::set_parameter_types(oop constructor, oop value) { | |
| 1709 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1710 constructor->obj_field_put(parameterTypes_offset, value); | |
| 1711 } | |
| 1712 | |
| 1713 oop java_lang_reflect_Constructor::exception_types(oop constructor) { | |
| 1714 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1715 return constructor->obj_field(exceptionTypes_offset); | |
| 1716 } | |
| 1717 | |
| 1718 void java_lang_reflect_Constructor::set_exception_types(oop constructor, oop value) { | |
| 1719 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1720 constructor->obj_field_put(exceptionTypes_offset, value); | |
| 1721 } | |
| 1722 | |
| 1723 int java_lang_reflect_Constructor::slot(oop reflect) { | |
| 1724 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1725 return reflect->int_field(slot_offset); | |
| 1726 } | |
| 1727 | |
| 1728 void java_lang_reflect_Constructor::set_slot(oop reflect, int value) { | |
| 1729 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1730 reflect->int_field_put(slot_offset, value); | |
| 1731 } | |
| 1732 | |
| 1733 int java_lang_reflect_Constructor::modifiers(oop constructor) { | |
| 1734 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1735 return constructor->int_field(modifiers_offset); | |
| 1736 } | |
| 1737 | |
| 1738 void java_lang_reflect_Constructor::set_modifiers(oop constructor, int value) { | |
| 1739 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1740 constructor->int_field_put(modifiers_offset, value); | |
| 1741 } | |
| 1742 | |
| 1743 bool java_lang_reflect_Constructor::has_signature_field() { | |
| 1744 return (signature_offset >= 0); | |
| 1745 } | |
| 1746 | |
| 1747 oop java_lang_reflect_Constructor::signature(oop constructor) { | |
| 1748 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1749 assert(has_signature_field(), "signature field must be present"); | |
| 1750 return constructor->obj_field(signature_offset); | |
| 1751 } | |
| 1752 | |
| 1753 void java_lang_reflect_Constructor::set_signature(oop constructor, oop value) { | |
| 1754 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1755 assert(has_signature_field(), "signature field must be present"); | |
| 1756 constructor->obj_field_put(signature_offset, value); | |
| 1757 } | |
| 1758 | |
| 1759 bool java_lang_reflect_Constructor::has_annotations_field() { | |
| 1760 return (annotations_offset >= 0); | |
| 1761 } | |
| 1762 | |
| 1763 oop java_lang_reflect_Constructor::annotations(oop constructor) { | |
| 1764 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1765 assert(has_annotations_field(), "annotations field must be present"); | |
| 1766 return constructor->obj_field(annotations_offset); | |
| 1767 } | |
| 1768 | |
| 1769 void java_lang_reflect_Constructor::set_annotations(oop constructor, oop value) { | |
| 1770 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1771 assert(has_annotations_field(), "annotations field must be present"); | |
| 1772 constructor->obj_field_put(annotations_offset, value); | |
| 1773 } | |
| 1774 | |
| 1775 bool java_lang_reflect_Constructor::has_parameter_annotations_field() { | |
| 1776 return (parameter_annotations_offset >= 0); | |
| 1777 } | |
| 1778 | |
| 1779 oop java_lang_reflect_Constructor::parameter_annotations(oop method) { | |
| 1780 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1781 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); | |
| 1782 return method->obj_field(parameter_annotations_offset); | |
| 1783 } | |
| 1784 | |
| 1785 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) { | |
| 1786 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1787 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); | |
| 1788 method->obj_field_put(parameter_annotations_offset, value); | |
| 1789 } | |
| 1790 | |
| 1791 void java_lang_reflect_Field::compute_offsets() { | |
| 1792 klassOop k = SystemDictionary::reflect_field_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1793 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1794 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1795 compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1796 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1797 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
| 0 | 1798 // The generic signature and annotations fields are only present in 1.5 |
| 1799 signature_offset = -1; | |
| 1800 annotations_offset = -1; | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1801 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1802 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); |
| 0 | 1803 } |
| 1804 | |
| 1805 Handle java_lang_reflect_Field::create(TRAPS) { | |
| 1806 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1807 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field(); | |
| 1808 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); | |
| 1809 instanceKlassHandle klass (THREAD, k); | |
| 1810 // Ensure it is initialized | |
| 1811 klass->initialize(CHECK_NH); | |
| 1812 return klass->allocate_instance_handle(CHECK_NH); | |
| 1813 } | |
| 1814 | |
| 1815 oop java_lang_reflect_Field::clazz(oop reflect) { | |
| 1816 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1817 return reflect->obj_field(clazz_offset); | |
| 1818 } | |
| 1819 | |
| 1820 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) { | |
| 1821 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1822 reflect->obj_field_put(clazz_offset, value); | |
| 1823 } | |
| 1824 | |
| 1825 oop java_lang_reflect_Field::name(oop field) { | |
| 1826 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1827 return field->obj_field(name_offset); | |
| 1828 } | |
| 1829 | |
| 1830 void java_lang_reflect_Field::set_name(oop field, oop value) { | |
| 1831 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1832 field->obj_field_put(name_offset, value); | |
| 1833 } | |
| 1834 | |
| 1835 oop java_lang_reflect_Field::type(oop field) { | |
| 1836 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1837 return field->obj_field(type_offset); | |
| 1838 } | |
| 1839 | |
| 1840 void java_lang_reflect_Field::set_type(oop field, oop value) { | |
| 1841 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1842 field->obj_field_put(type_offset, value); | |
| 1843 } | |
| 1844 | |
| 1845 int java_lang_reflect_Field::slot(oop reflect) { | |
| 1846 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1847 return reflect->int_field(slot_offset); | |
| 1848 } | |
| 1849 | |
| 1850 void java_lang_reflect_Field::set_slot(oop reflect, int value) { | |
| 1851 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1852 reflect->int_field_put(slot_offset, value); | |
| 1853 } | |
| 1854 | |
| 1855 int java_lang_reflect_Field::modifiers(oop field) { | |
| 1856 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1857 return field->int_field(modifiers_offset); | |
| 1858 } | |
| 1859 | |
| 1860 void java_lang_reflect_Field::set_modifiers(oop field, int value) { | |
| 1861 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1862 field->int_field_put(modifiers_offset, value); | |
| 1863 } | |
| 1864 | |
| 1865 bool java_lang_reflect_Field::has_signature_field() { | |
| 1866 return (signature_offset >= 0); | |
| 1867 } | |
| 1868 | |
| 1869 oop java_lang_reflect_Field::signature(oop field) { | |
| 1870 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1871 assert(has_signature_field(), "signature field must be present"); | |
| 1872 return field->obj_field(signature_offset); | |
| 1873 } | |
| 1874 | |
| 1875 void java_lang_reflect_Field::set_signature(oop field, oop value) { | |
| 1876 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1877 assert(has_signature_field(), "signature field must be present"); | |
| 1878 field->obj_field_put(signature_offset, value); | |
| 1879 } | |
| 1880 | |
| 1881 bool java_lang_reflect_Field::has_annotations_field() { | |
| 1882 return (annotations_offset >= 0); | |
| 1883 } | |
| 1884 | |
| 1885 oop java_lang_reflect_Field::annotations(oop field) { | |
| 1886 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1887 assert(has_annotations_field(), "annotations field must be present"); | |
| 1888 return field->obj_field(annotations_offset); | |
| 1889 } | |
| 1890 | |
| 1891 void java_lang_reflect_Field::set_annotations(oop field, oop value) { | |
| 1892 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1893 assert(has_annotations_field(), "annotations field must be present"); | |
| 1894 field->obj_field_put(annotations_offset, value); | |
| 1895 } | |
| 1896 | |
| 1897 | |
| 1898 void sun_reflect_ConstantPool::compute_offsets() { | |
| 1899 klassOop k = SystemDictionary::reflect_constant_pool_klass(); | |
| 1900 // This null test can be removed post beta | |
| 1901 if (k != NULL) { | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1902 compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature()); |
| 0 | 1903 } |
| 1904 } | |
| 1905 | |
| 1906 | |
| 1907 Handle sun_reflect_ConstantPool::create(TRAPS) { | |
| 1908 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1909 klassOop k = SystemDictionary::reflect_constant_pool_klass(); | |
| 1910 instanceKlassHandle klass (THREAD, k); | |
| 1911 // Ensure it is initialized | |
| 1912 klass->initialize(CHECK_NH); | |
| 1913 return klass->allocate_instance_handle(CHECK_NH); | |
| 1914 } | |
| 1915 | |
| 1916 | |
| 1917 oop sun_reflect_ConstantPool::cp_oop(oop reflect) { | |
| 1918 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1919 return reflect->obj_field(_cp_oop_offset); | |
| 1920 } | |
| 1921 | |
| 1922 | |
| 1923 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) { | |
| 1924 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | |
| 1925 reflect->obj_field_put(_cp_oop_offset, value); | |
| 1926 } | |
| 1927 | |
| 1928 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { | |
| 1929 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass(); | |
| 1930 // This null test can be removed post beta | |
| 1931 if (k != NULL) { | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1932 compute_offset(_base_offset, k, |
| 0 | 1933 vmSymbols::base_name(), vmSymbols::object_signature()); |
| 1934 } | |
| 1935 } | |
| 1936 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1937 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1938 klassOop k = SystemDictionary::box_klass(type); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1939 if (k == NULL) return NULL; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1940 instanceKlassHandle h (THREAD, k); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1941 if (!h->is_initialized()) h->initialize(CHECK_0); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1942 return h->allocate_instance(THREAD); |
| 0 | 1943 } |
| 1944 | |
| 1945 | |
| 1946 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) { | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1947 oop box = initialize_and_allocate(type, CHECK_0); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1948 if (box == NULL) return NULL; |
| 0 | 1949 switch (type) { |
| 1950 case T_BOOLEAN: | |
| 1951 box->bool_field_put(value_offset, value->z); | |
| 1952 break; | |
| 1953 case T_CHAR: | |
| 1954 box->char_field_put(value_offset, value->c); | |
| 1955 break; | |
| 1956 case T_FLOAT: | |
| 1957 box->float_field_put(value_offset, value->f); | |
| 1958 break; | |
| 1959 case T_DOUBLE: | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
1960 box->double_field_put(long_value_offset, value->d); |
| 0 | 1961 break; |
| 1962 case T_BYTE: | |
| 1963 box->byte_field_put(value_offset, value->b); | |
| 1964 break; | |
| 1965 case T_SHORT: | |
| 1966 box->short_field_put(value_offset, value->s); | |
| 1967 break; | |
| 1968 case T_INT: | |
| 1969 box->int_field_put(value_offset, value->i); | |
| 1970 break; | |
| 1971 case T_LONG: | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
1972 box->long_field_put(long_value_offset, value->j); |
| 0 | 1973 break; |
| 1974 default: | |
| 1975 return NULL; | |
| 1976 } | |
| 1977 return box; | |
| 1978 } | |
| 1979 | |
| 1980 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1981 BasicType java_lang_boxing_object::basic_type(oop box) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1982 if (box == NULL) return T_ILLEGAL; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1983 BasicType type = SystemDictionary::box_klass_type(box->klass()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1984 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1985 return T_ILLEGAL; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1986 return type; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1987 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1988 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1989 |
| 0 | 1990 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) { |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1991 BasicType type = SystemDictionary::box_klass_type(box->klass()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1992 switch (type) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1993 case T_BOOLEAN: |
| 0 | 1994 value->z = box->bool_field(value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1995 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1996 case T_CHAR: |
| 0 | 1997 value->c = box->char_field(value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1998 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1999 case T_FLOAT: |
| 0 | 2000 value->f = box->float_field(value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2001 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2002 case T_DOUBLE: |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2003 value->d = box->double_field(long_value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2004 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2005 case T_BYTE: |
| 0 | 2006 value->b = box->byte_field(value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2007 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2008 case T_SHORT: |
| 0 | 2009 value->s = box->short_field(value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2010 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2011 case T_INT: |
| 0 | 2012 value->i = box->int_field(value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2013 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2014 case T_LONG: |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2015 value->j = box->long_field(long_value_offset); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2016 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2017 default: |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2018 return T_ILLEGAL; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2019 } // end switch |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2020 return type; |
| 0 | 2021 } |
| 2022 | |
| 2023 | |
| 2024 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) { | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2025 BasicType type = SystemDictionary::box_klass_type(box->klass()); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2026 switch (type) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2027 case T_BOOLEAN: |
| 0 | 2028 box->bool_field_put(value_offset, value->z); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2029 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2030 case T_CHAR: |
| 0 | 2031 box->char_field_put(value_offset, value->c); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2032 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2033 case T_FLOAT: |
| 0 | 2034 box->float_field_put(value_offset, value->f); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2035 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2036 case T_DOUBLE: |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2037 box->double_field_put(long_value_offset, value->d); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2038 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2039 case T_BYTE: |
| 0 | 2040 box->byte_field_put(value_offset, value->b); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2041 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2042 case T_SHORT: |
| 0 | 2043 box->short_field_put(value_offset, value->s); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2044 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2045 case T_INT: |
| 0 | 2046 box->int_field_put(value_offset, value->i); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2047 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2048 case T_LONG: |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2049 box->long_field_put(long_value_offset, value->j); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2050 break; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2051 default: |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2052 return T_ILLEGAL; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2053 } // end switch |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2054 return type; |
| 0 | 2055 } |
| 2056 | |
| 2057 | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2058 void java_lang_boxing_object::print(BasicType type, jvalue* value, outputStream* st) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2059 switch (type) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2060 case T_BOOLEAN: st->print("%s", value->z ? "true" : "false"); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2061 case T_CHAR: st->print("%d", value->c); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2062 case T_BYTE: st->print("%d", value->b); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2063 case T_SHORT: st->print("%d", value->s); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2064 case T_INT: st->print("%d", value->i); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2065 case T_LONG: st->print(INT64_FORMAT, value->j); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2066 case T_FLOAT: st->print("%f", value->f); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2067 case T_DOUBLE: st->print("%lf", value->d); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2068 default: st->print("type %d?", type); break; |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2069 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2070 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2071 |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2072 |
| 0 | 2073 // Support for java_lang_ref_Reference |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2074 oop java_lang_ref_Reference::pending_list_lock() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2075 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2076 char *addr = (((char *)ik->start_of_static_fields()) + static_lock_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2077 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2078 return oopDesc::load_decode_heap_oop((narrowOop *)addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2079 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2080 return oopDesc::load_decode_heap_oop((oop*)addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2081 } |
| 0 | 2082 } |
| 2083 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2084 HeapWord *java_lang_ref_Reference::pending_list_addr() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2085 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2086 char *addr = (((char *)ik->start_of_static_fields()) + static_pending_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2087 // XXX This might not be HeapWord aligned, almost rather be char *. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2088 return (HeapWord*)addr; |
| 0 | 2089 } |
| 2090 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2091 oop java_lang_ref_Reference::pending_list() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2092 char *addr = (char *)pending_list_addr(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2093 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2094 return oopDesc::load_decode_heap_oop((narrowOop *)addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2095 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2096 return oopDesc::load_decode_heap_oop((oop*)addr); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2097 } |
| 0 | 2098 } |
| 2099 | |
| 2100 | |
| 2101 // Support for java_lang_ref_SoftReference | |
| 2102 | |
| 2103 jlong java_lang_ref_SoftReference::timestamp(oop ref) { | |
| 2104 return ref->long_field(timestamp_offset); | |
| 2105 } | |
| 2106 | |
| 2107 jlong java_lang_ref_SoftReference::clock() { | |
| 2108 instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass()); | |
| 2109 int offset = ik->offset_of_static_fields() + static_clock_offset; | |
| 2110 | |
| 2111 return SystemDictionary::soft_reference_klass()->long_field(offset); | |
| 2112 } | |
| 2113 | |
| 2114 void java_lang_ref_SoftReference::set_clock(jlong value) { | |
| 2115 instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass()); | |
| 2116 int offset = ik->offset_of_static_fields() + static_clock_offset; | |
| 2117 | |
| 2118 SystemDictionary::soft_reference_klass()->long_field_put(offset, value); | |
| 2119 } | |
| 2120 | |
| 2121 | |
| 710 | 2122 // Support for java_dyn_MethodHandle |
| 2123 | |
| 2124 int java_dyn_MethodHandle::_type_offset; | |
| 2125 int java_dyn_MethodHandle::_vmtarget_offset; | |
| 2126 int java_dyn_MethodHandle::_vmentry_offset; | |
| 2127 int java_dyn_MethodHandle::_vmslots_offset; | |
| 2128 | |
| 2129 int sun_dyn_MemberName::_clazz_offset; | |
| 2130 int sun_dyn_MemberName::_name_offset; | |
| 2131 int sun_dyn_MemberName::_type_offset; | |
| 2132 int sun_dyn_MemberName::_flags_offset; | |
| 2133 int sun_dyn_MemberName::_vmtarget_offset; | |
| 2134 int sun_dyn_MemberName::_vmindex_offset; | |
| 2135 | |
| 2136 int sun_dyn_DirectMethodHandle::_vmindex_offset; | |
| 2137 | |
| 2138 int sun_dyn_BoundMethodHandle::_argument_offset; | |
| 2139 int sun_dyn_BoundMethodHandle::_vmargslot_offset; | |
| 2140 | |
| 2141 int sun_dyn_AdapterMethodHandle::_conversion_offset; | |
| 2142 | |
| 2143 void java_dyn_MethodHandle::compute_offsets() { | |
| 2144 klassOop k = SystemDictionary::MethodHandle_klass(); | |
| 2145 if (k != NULL && EnableMethodHandles) { | |
| 2146 compute_offset(_type_offset, k, vmSymbols::type_name(), vmSymbols::java_dyn_MethodType_signature(), true); | |
| 2147 compute_offset(_vmtarget_offset, k, vmSymbols::vmtarget_name(), vmSymbols::object_signature(), true); | |
| 2148 compute_offset(_vmentry_offset, k, vmSymbols::vmentry_name(), vmSymbols::machine_word_signature(), true); | |
| 2149 | |
| 2150 // Note: MH.vmslots (if it is present) is a hoisted copy of MH.type.form.vmslots. | |
| 2151 // It is optional pending experiments to keep or toss. | |
| 2152 compute_optional_offset(_vmslots_offset, k, vmSymbols::vmslots_name(), vmSymbols::int_signature(), true); | |
| 2153 } | |
| 2154 } | |
| 2155 | |
| 2156 void sun_dyn_MemberName::compute_offsets() { | |
| 2157 klassOop k = SystemDictionary::MemberName_klass(); | |
| 2158 if (k != NULL && EnableMethodHandles) { | |
| 2159 compute_offset(_clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); | |
| 2160 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); | |
| 2161 compute_offset(_type_offset, k, vmSymbols::type_name(), vmSymbols::object_signature()); | |
| 2162 compute_offset(_flags_offset, k, vmSymbols::flags_name(), vmSymbols::int_signature()); | |
| 2163 compute_offset(_vmtarget_offset, k, vmSymbols::vmtarget_name(), vmSymbols::object_signature()); | |
| 2164 compute_offset(_vmindex_offset, k, vmSymbols::vmindex_name(), vmSymbols::int_signature()); | |
| 2165 } | |
| 2166 } | |
| 2167 | |
| 2168 void sun_dyn_DirectMethodHandle::compute_offsets() { | |
| 2169 klassOop k = SystemDictionary::DirectMethodHandle_klass(); | |
| 2170 if (k != NULL && EnableMethodHandles) { | |
| 2171 compute_offset(_vmindex_offset, k, vmSymbols::vmindex_name(), vmSymbols::int_signature(), true); | |
| 2172 } | |
| 2173 } | |
| 2174 | |
| 2175 void sun_dyn_BoundMethodHandle::compute_offsets() { | |
| 2176 klassOop k = SystemDictionary::BoundMethodHandle_klass(); | |
| 2177 if (k != NULL && EnableMethodHandles) { | |
| 2178 compute_offset(_vmargslot_offset, k, vmSymbols::vmargslot_name(), vmSymbols::int_signature(), true); | |
| 2179 compute_offset(_argument_offset, k, vmSymbols::argument_name(), vmSymbols::object_signature(), true); | |
| 2180 } | |
| 2181 } | |
| 2182 | |
| 2183 void sun_dyn_AdapterMethodHandle::compute_offsets() { | |
| 2184 klassOop k = SystemDictionary::AdapterMethodHandle_klass(); | |
| 2185 if (k != NULL && EnableMethodHandles) { | |
| 2186 compute_offset(_conversion_offset, k, vmSymbols::conversion_name(), vmSymbols::int_signature(), true); | |
| 2187 } | |
| 2188 } | |
| 2189 | |
| 2190 oop java_dyn_MethodHandle::type(oop mh) { | |
| 2191 return mh->obj_field(_type_offset); | |
| 2192 } | |
| 2193 | |
| 2194 void java_dyn_MethodHandle::set_type(oop mh, oop mtype) { | |
| 2195 mh->obj_field_put(_type_offset, mtype); | |
| 2196 } | |
| 2197 | |
| 2198 int java_dyn_MethodHandle::vmslots(oop mh) { | |
| 2199 int vmslots_offset = _vmslots_offset; | |
| 2200 if (vmslots_offset != 0) { | |
| 2201 #ifdef ASSERT | |
| 2202 int x = mh->int_field(vmslots_offset); | |
| 2203 int y = compute_vmslots(mh); | |
| 2204 assert(x == y, "correct hoisted value"); | |
| 2205 #endif | |
| 2206 return mh->int_field(vmslots_offset); | |
| 2207 } else { | |
| 2208 return compute_vmslots(mh); | |
| 2209 } | |
| 2210 } | |
| 2211 | |
| 2212 // if MH.vmslots exists, hoist into it the value of type.form.vmslots | |
| 2213 void java_dyn_MethodHandle::init_vmslots(oop mh) { | |
| 2214 int vmslots_offset = _vmslots_offset; | |
| 2215 if (vmslots_offset != 0) { | |
| 2216 mh->int_field_put(vmslots_offset, compute_vmslots(mh)); | |
| 2217 } | |
| 2218 } | |
| 2219 | |
| 2220 // fetch type.form.vmslots, which is the number of JVM stack slots | |
| 2221 // required to carry the arguments of this MH | |
| 2222 int java_dyn_MethodHandle::compute_vmslots(oop mh) { | |
| 2223 oop mtype = type(mh); | |
| 2224 if (mtype == NULL) return 0; // Java code would get NPE | |
| 2225 oop form = java_dyn_MethodType::form(mtype); | |
| 2226 if (form == NULL) return 0; // Java code would get NPE | |
| 2227 return java_dyn_MethodTypeForm::vmslots(form); | |
| 2228 } | |
| 2229 | |
| 2230 // fetch the low-level entry point for this mh | |
| 2231 MethodHandleEntry* java_dyn_MethodHandle::vmentry(oop mh) { | |
| 2232 return (MethodHandleEntry*) mh->address_field(_vmentry_offset); | |
| 2233 } | |
| 2234 | |
| 2235 void java_dyn_MethodHandle::set_vmentry(oop mh, MethodHandleEntry* me) { | |
| 2236 assert(_vmentry_offset != 0, "must be present"); | |
| 2237 | |
| 2238 // This is always the final step that initializes a valid method handle: | |
| 2239 mh->release_address_field_put(_vmentry_offset, (address) me); | |
| 2240 | |
| 2241 // There should be enough memory barriers on exit from native methods | |
| 2242 // to ensure that the MH is fully initialized to all threads before | |
| 2243 // Java code can publish it in global data structures. | |
| 2244 // But just in case, we use release_address_field_put. | |
| 2245 } | |
| 2246 | |
| 2247 /// MemberName accessors | |
| 2248 | |
| 2249 oop sun_dyn_MemberName::clazz(oop mname) { | |
| 2250 assert(is_instance(mname), "wrong type"); | |
| 2251 return mname->obj_field(_clazz_offset); | |
| 2252 } | |
| 2253 | |
| 2254 void sun_dyn_MemberName::set_clazz(oop mname, oop clazz) { | |
| 2255 assert(is_instance(mname), "wrong type"); | |
| 2256 mname->obj_field_put(_clazz_offset, clazz); | |
| 2257 } | |
| 2258 | |
| 2259 oop sun_dyn_MemberName::name(oop mname) { | |
| 2260 assert(is_instance(mname), "wrong type"); | |
| 2261 return mname->obj_field(_name_offset); | |
| 2262 } | |
| 2263 | |
| 2264 void sun_dyn_MemberName::set_name(oop mname, oop name) { | |
| 2265 assert(is_instance(mname), "wrong type"); | |
| 2266 mname->obj_field_put(_name_offset, name); | |
| 2267 } | |
| 2268 | |
| 2269 oop sun_dyn_MemberName::type(oop mname) { | |
| 2270 assert(is_instance(mname), "wrong type"); | |
| 2271 return mname->obj_field(_type_offset); | |
| 2272 } | |
| 2273 | |
| 2274 void sun_dyn_MemberName::set_type(oop mname, oop type) { | |
| 2275 assert(is_instance(mname), "wrong type"); | |
| 2276 mname->obj_field_put(_type_offset, type); | |
| 2277 } | |
| 2278 | |
| 2279 int sun_dyn_MemberName::flags(oop mname) { | |
| 2280 assert(is_instance(mname), "wrong type"); | |
| 2281 return mname->int_field(_flags_offset); | |
| 2282 } | |
| 2283 | |
| 2284 void sun_dyn_MemberName::set_flags(oop mname, int flags) { | |
| 2285 assert(is_instance(mname), "wrong type"); | |
| 2286 mname->int_field_put(_flags_offset, flags); | |
| 2287 } | |
| 2288 | |
| 2289 oop sun_dyn_MemberName::vmtarget(oop mname) { | |
| 2290 assert(is_instance(mname), "wrong type"); | |
| 2291 return mname->obj_field(_vmtarget_offset); | |
| 2292 } | |
| 2293 | |
| 2294 void sun_dyn_MemberName::set_vmtarget(oop mname, oop ref) { | |
| 2295 assert(is_instance(mname), "wrong type"); | |
| 2296 mname->obj_field_put(_vmtarget_offset, ref); | |
| 2297 } | |
| 2298 | |
| 2299 int sun_dyn_MemberName::vmindex(oop mname) { | |
| 2300 assert(is_instance(mname), "wrong type"); | |
| 2301 return mname->int_field(_vmindex_offset); | |
| 2302 } | |
| 2303 | |
| 2304 void sun_dyn_MemberName::set_vmindex(oop mname, int index) { | |
| 2305 assert(is_instance(mname), "wrong type"); | |
| 2306 mname->int_field_put(_vmindex_offset, index); | |
| 2307 } | |
| 2308 | |
| 2309 oop java_dyn_MethodHandle::vmtarget(oop mh) { | |
| 2310 assert(is_instance(mh), "MH only"); | |
| 2311 return mh->obj_field(_vmtarget_offset); | |
| 2312 } | |
| 2313 | |
| 2314 void java_dyn_MethodHandle::set_vmtarget(oop mh, oop ref) { | |
| 2315 assert(is_instance(mh), "MH only"); | |
| 2316 mh->obj_field_put(_vmtarget_offset, ref); | |
| 2317 } | |
| 2318 | |
| 2319 int sun_dyn_DirectMethodHandle::vmindex(oop mh) { | |
| 2320 assert(is_instance(mh), "DMH only"); | |
| 2321 return mh->int_field(_vmindex_offset); | |
| 2322 } | |
| 2323 | |
| 2324 void sun_dyn_DirectMethodHandle::set_vmindex(oop mh, int index) { | |
| 2325 assert(is_instance(mh), "DMH only"); | |
| 2326 mh->int_field_put(_vmindex_offset, index); | |
| 2327 } | |
| 2328 | |
| 2329 int sun_dyn_BoundMethodHandle::vmargslot(oop mh) { | |
| 2330 assert(is_instance(mh), "BMH only"); | |
| 2331 return mh->int_field(_vmargslot_offset); | |
| 2332 } | |
| 2333 | |
| 2334 oop sun_dyn_BoundMethodHandle::argument(oop mh) { | |
| 2335 assert(is_instance(mh), "BMH only"); | |
| 2336 return mh->obj_field(_argument_offset); | |
| 2337 } | |
| 2338 | |
| 2339 int sun_dyn_AdapterMethodHandle::conversion(oop mh) { | |
| 2340 assert(is_instance(mh), "AMH only"); | |
| 2341 return mh->int_field(_conversion_offset); | |
| 2342 } | |
| 2343 | |
| 2344 void sun_dyn_AdapterMethodHandle::set_conversion(oop mh, int conv) { | |
| 2345 assert(is_instance(mh), "AMH only"); | |
| 2346 mh->int_field_put(_conversion_offset, conv); | |
| 2347 } | |
| 2348 | |
| 2349 | |
| 2350 // Support for java_dyn_MethodType | |
| 2351 | |
| 2352 int java_dyn_MethodType::_rtype_offset; | |
| 2353 int java_dyn_MethodType::_ptypes_offset; | |
| 2354 int java_dyn_MethodType::_form_offset; | |
| 2355 | |
| 2356 void java_dyn_MethodType::compute_offsets() { | |
| 2357 klassOop k = SystemDictionary::MethodType_klass(); | |
| 2358 if (k != NULL) { | |
| 2359 compute_offset(_rtype_offset, k, vmSymbols::rtype_name(), vmSymbols::class_signature()); | |
| 2360 compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature()); | |
| 2361 compute_offset(_form_offset, k, vmSymbols::form_name(), vmSymbols::java_dyn_MethodTypeForm_signature()); | |
| 2362 } | |
| 2363 } | |
| 2364 | |
| 2365 void java_dyn_MethodType::print_signature(oop mt, outputStream* st) { | |
| 2366 st->print("("); | |
| 2367 objArrayOop pts = ptypes(mt); | |
| 2368 for (int i = 0, limit = pts->length(); i < limit; i++) { | |
| 2369 java_lang_Class::print_signature(pts->obj_at(i), st); | |
| 2370 } | |
| 2371 st->print(")"); | |
| 2372 java_lang_Class::print_signature(rtype(mt), st); | |
| 2373 } | |
| 2374 | |
| 2375 symbolOop java_dyn_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) { | |
| 2376 ResourceMark rm; | |
| 2377 stringStream buffer(128); | |
| 2378 print_signature(mt, &buffer); | |
| 2379 const char* sigstr = buffer.base(); | |
| 2380 int siglen = (int) buffer.size(); | |
| 2381 if (!intern_if_not_found) | |
| 2382 return SymbolTable::probe(sigstr, siglen); | |
| 2383 else | |
| 2384 return oopFactory::new_symbol(sigstr, siglen, THREAD); | |
| 2385 } | |
| 2386 | |
| 2387 oop java_dyn_MethodType::rtype(oop mt) { | |
| 2388 assert(is_instance(mt), "must be a MethodType"); | |
| 2389 return mt->obj_field(_rtype_offset); | |
| 2390 } | |
| 2391 | |
| 2392 objArrayOop java_dyn_MethodType::ptypes(oop mt) { | |
| 2393 assert(is_instance(mt), "must be a MethodType"); | |
| 2394 return (objArrayOop) mt->obj_field(_ptypes_offset); | |
| 2395 } | |
| 2396 | |
| 2397 oop java_dyn_MethodType::form(oop mt) { | |
| 2398 assert(is_instance(mt), "must be a MethodType"); | |
| 2399 return mt->obj_field(_form_offset); | |
| 2400 } | |
| 2401 | |
| 2402 oop java_dyn_MethodType::ptype(oop mt, int idx) { | |
| 2403 return ptypes(mt)->obj_at(idx); | |
| 2404 } | |
| 2405 | |
| 2406 | |
| 2407 | |
| 2408 // Support for java_dyn_MethodTypeForm | |
| 2409 | |
| 2410 int java_dyn_MethodTypeForm::_vmslots_offset; | |
| 2411 int java_dyn_MethodTypeForm::_erasedType_offset; | |
| 2412 | |
| 2413 void java_dyn_MethodTypeForm::compute_offsets() { | |
| 2414 klassOop k = SystemDictionary::MethodTypeForm_klass(); | |
| 2415 if (k != NULL) { | |
| 2416 compute_optional_offset(_vmslots_offset, k, vmSymbols::vmslots_name(), vmSymbols::int_signature(), true); | |
| 2417 compute_optional_offset(_erasedType_offset, k, vmSymbols::erasedType_name(), vmSymbols::java_dyn_MethodType_signature(), true); | |
| 2418 } | |
| 2419 } | |
| 2420 | |
| 2421 int java_dyn_MethodTypeForm::vmslots(oop mtform) { | |
| 2422 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only"); | |
| 2423 return mtform->int_field(_vmslots_offset); | |
| 2424 } | |
| 2425 | |
| 2426 oop java_dyn_MethodTypeForm::erasedType(oop mtform) { | |
| 2427 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only"); | |
| 2428 return mtform->obj_field(_erasedType_offset); | |
| 2429 } | |
| 2430 | |
| 2431 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2432 // Support for sun_dyn_CallSiteImpl |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2433 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2434 int sun_dyn_CallSiteImpl::_type_offset; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2435 int sun_dyn_CallSiteImpl::_target_offset; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2436 int sun_dyn_CallSiteImpl::_vmmethod_offset; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2437 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2438 void sun_dyn_CallSiteImpl::compute_offsets() { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2439 if (!EnableInvokeDynamic) return; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2440 klassOop k = SystemDictionary::CallSiteImpl_klass(); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2441 if (k != NULL) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2442 compute_offset(_type_offset, k, vmSymbols::type_name(), vmSymbols::java_dyn_MethodType_signature(), true); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2443 compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_dyn_MethodHandle_signature(), true); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2444 compute_offset(_vmmethod_offset, k, vmSymbols::vmmethod_name(), vmSymbols::object_signature(), true); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2445 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2446 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2447 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2448 oop sun_dyn_CallSiteImpl::type(oop site) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2449 return site->obj_field(_type_offset); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2450 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2451 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2452 oop sun_dyn_CallSiteImpl::target(oop site) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2453 return site->obj_field(_target_offset); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2454 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2455 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2456 void sun_dyn_CallSiteImpl::set_target(oop site, oop target) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2457 site->obj_field_put(_target_offset, target); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2458 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2459 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2460 oop sun_dyn_CallSiteImpl::vmmethod(oop site) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2461 return site->obj_field(_vmmethod_offset); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2462 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2463 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2464 void sun_dyn_CallSiteImpl::set_vmmethod(oop site, oop ref) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2465 site->obj_field_put(_vmmethod_offset, ref); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2466 } |
| 710 | 2467 |
| 2468 | |
| 0 | 2469 // Support for java_security_AccessControlContext |
| 2470 | |
| 2471 int java_security_AccessControlContext::_context_offset = 0; | |
| 2472 int java_security_AccessControlContext::_privilegedContext_offset = 0; | |
| 2473 int java_security_AccessControlContext::_isPrivileged_offset = 0; | |
| 2474 | |
| 2475 void java_security_AccessControlContext::compute_offsets() { | |
| 2476 assert(_isPrivileged_offset == 0, "offsets should be initialized only once"); | |
| 2477 fieldDescriptor fd; | |
| 2478 instanceKlass* ik = instanceKlass::cast(SystemDictionary::AccessControlContext_klass()); | |
| 2479 | |
| 2480 if (!ik->find_local_field(vmSymbols::context_name(), vmSymbols::protectiondomain_signature(), &fd)) { | |
| 2481 fatal("Invalid layout of java.security.AccessControlContext"); | |
| 2482 } | |
| 2483 _context_offset = fd.offset(); | |
| 2484 | |
| 2485 if (!ik->find_local_field(vmSymbols::privilegedContext_name(), vmSymbols::accesscontrolcontext_signature(), &fd)) { | |
| 2486 fatal("Invalid layout of java.security.AccessControlContext"); | |
| 2487 } | |
| 2488 _privilegedContext_offset = fd.offset(); | |
| 2489 | |
| 2490 if (!ik->find_local_field(vmSymbols::isPrivileged_name(), vmSymbols::bool_signature(), &fd)) { | |
| 2491 fatal("Invalid layout of java.security.AccessControlContext"); | |
| 2492 } | |
| 2493 _isPrivileged_offset = fd.offset(); | |
| 2494 } | |
| 2495 | |
| 2496 | |
| 2497 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) { | |
| 2498 assert(_isPrivileged_offset != 0, "offsets should have been initialized"); | |
| 2499 // Ensure klass is initialized | |
| 2500 instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0); | |
| 2501 // Allocate result | |
| 2502 oop result = instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0); | |
| 2503 // Fill in values | |
| 2504 result->obj_field_put(_context_offset, context()); | |
| 2505 result->obj_field_put(_privilegedContext_offset, privileged_context()); | |
| 2506 result->bool_field_put(_isPrivileged_offset, isPrivileged); | |
| 2507 return result; | |
| 2508 } | |
| 2509 | |
| 2510 | |
| 2511 // Support for java_lang_ClassLoader | |
| 2512 | |
| 2513 oop java_lang_ClassLoader::parent(oop loader) { | |
| 2514 assert(loader->is_oop(), "loader must be oop"); | |
| 2515 return loader->obj_field(parent_offset); | |
| 2516 } | |
| 2517 | |
| 2518 | |
| 2519 bool java_lang_ClassLoader::is_trusted_loader(oop loader) { | |
| 2520 // Fix for 4474172; see evaluation for more details | |
| 2521 loader = non_reflection_class_loader(loader); | |
| 2522 | |
| 2523 oop cl = SystemDictionary::java_system_loader(); | |
| 2524 while(cl != NULL) { | |
| 2525 if (cl == loader) return true; | |
| 2526 cl = parent(cl); | |
| 2527 } | |
| 2528 return false; | |
| 2529 } | |
| 2530 | |
| 2531 oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) { | |
| 2532 if (loader != NULL) { | |
| 2533 // See whether this is one of the class loaders associated with | |
| 2534 // the generated bytecodes for reflection, and if so, "magically" | |
| 2535 // delegate to its parent to prevent class loading from occurring | |
| 2536 // in places where applications using reflection didn't expect it. | |
| 2537 klassOop delegating_cl_class = SystemDictionary::reflect_delegating_classloader_klass(); | |
| 2538 // This might be null in non-1.4 JDKs | |
| 2539 if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) { | |
| 2540 return parent(loader); | |
| 2541 } | |
| 2542 } | |
| 2543 return loader; | |
| 2544 } | |
| 2545 | |
| 2546 | |
| 2547 // Support for java_lang_System | |
| 2548 | |
| 2549 void java_lang_System::compute_offsets() { | |
| 2550 assert(offset_of_static_fields == 0, "offsets should be initialized only once"); | |
| 2551 | |
| 2552 instanceKlass* ik = instanceKlass::cast(SystemDictionary::system_klass()); | |
| 2553 offset_of_static_fields = ik->offset_of_static_fields(); | |
| 2554 } | |
| 2555 | |
| 2556 int java_lang_System::in_offset_in_bytes() { | |
| 2557 return (offset_of_static_fields + static_in_offset); | |
| 2558 } | |
| 2559 | |
| 2560 | |
| 2561 int java_lang_System::out_offset_in_bytes() { | |
| 2562 return (offset_of_static_fields + static_out_offset); | |
| 2563 } | |
| 2564 | |
| 2565 | |
| 2566 int java_lang_System::err_offset_in_bytes() { | |
| 2567 return (offset_of_static_fields + static_err_offset); | |
| 2568 } | |
| 2569 | |
| 2570 | |
| 2571 | |
| 2572 int java_lang_String::value_offset; | |
| 2573 int java_lang_String::offset_offset; | |
| 2574 int java_lang_String::count_offset; | |
| 2575 int java_lang_String::hash_offset; | |
| 2576 int java_lang_Class::klass_offset; | |
| 2577 int java_lang_Class::array_klass_offset; | |
| 2578 int java_lang_Class::resolved_constructor_offset; | |
| 2579 int java_lang_Class::number_of_fake_oop_fields; | |
| 2580 int java_lang_Throwable::backtrace_offset; | |
| 2581 int java_lang_Throwable::detailMessage_offset; | |
| 2582 int java_lang_Throwable::cause_offset; | |
| 2583 int java_lang_Throwable::stackTrace_offset; | |
| 2584 int java_lang_reflect_AccessibleObject::override_offset; | |
| 2585 int java_lang_reflect_Method::clazz_offset; | |
| 2586 int java_lang_reflect_Method::name_offset; | |
| 2587 int java_lang_reflect_Method::returnType_offset; | |
| 2588 int java_lang_reflect_Method::parameterTypes_offset; | |
| 2589 int java_lang_reflect_Method::exceptionTypes_offset; | |
| 2590 int java_lang_reflect_Method::slot_offset; | |
| 2591 int java_lang_reflect_Method::modifiers_offset; | |
| 2592 int java_lang_reflect_Method::signature_offset; | |
| 2593 int java_lang_reflect_Method::annotations_offset; | |
| 2594 int java_lang_reflect_Method::parameter_annotations_offset; | |
| 2595 int java_lang_reflect_Method::annotation_default_offset; | |
| 2596 int java_lang_reflect_Constructor::clazz_offset; | |
| 2597 int java_lang_reflect_Constructor::parameterTypes_offset; | |
| 2598 int java_lang_reflect_Constructor::exceptionTypes_offset; | |
| 2599 int java_lang_reflect_Constructor::slot_offset; | |
| 2600 int java_lang_reflect_Constructor::modifiers_offset; | |
| 2601 int java_lang_reflect_Constructor::signature_offset; | |
| 2602 int java_lang_reflect_Constructor::annotations_offset; | |
| 2603 int java_lang_reflect_Constructor::parameter_annotations_offset; | |
| 2604 int java_lang_reflect_Field::clazz_offset; | |
| 2605 int java_lang_reflect_Field::name_offset; | |
| 2606 int java_lang_reflect_Field::type_offset; | |
| 2607 int java_lang_reflect_Field::slot_offset; | |
| 2608 int java_lang_reflect_Field::modifiers_offset; | |
| 2609 int java_lang_reflect_Field::signature_offset; | |
| 2610 int java_lang_reflect_Field::annotations_offset; | |
| 2611 int java_lang_boxing_object::value_offset; | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2612 int java_lang_boxing_object::long_value_offset; |
| 0 | 2613 int java_lang_ref_Reference::referent_offset; |
| 2614 int java_lang_ref_Reference::queue_offset; | |
| 2615 int java_lang_ref_Reference::next_offset; | |
| 2616 int java_lang_ref_Reference::discovered_offset; | |
| 2617 int java_lang_ref_Reference::static_lock_offset; | |
| 2618 int java_lang_ref_Reference::static_pending_offset; | |
| 2619 int java_lang_ref_Reference::number_of_fake_oop_fields; | |
| 2620 int java_lang_ref_SoftReference::timestamp_offset; | |
| 2621 int java_lang_ref_SoftReference::static_clock_offset; | |
| 2622 int java_lang_ClassLoader::parent_offset; | |
| 2623 int java_lang_System::offset_of_static_fields; | |
| 2624 int java_lang_System::static_in_offset; | |
| 2625 int java_lang_System::static_out_offset; | |
| 2626 int java_lang_System::static_err_offset; | |
| 2627 int java_lang_StackTraceElement::declaringClass_offset; | |
| 2628 int java_lang_StackTraceElement::methodName_offset; | |
| 2629 int java_lang_StackTraceElement::fileName_offset; | |
| 2630 int java_lang_StackTraceElement::lineNumber_offset; | |
| 2631 int java_lang_AssertionStatusDirectives::classes_offset; | |
| 2632 int java_lang_AssertionStatusDirectives::classEnabled_offset; | |
| 2633 int java_lang_AssertionStatusDirectives::packages_offset; | |
| 2634 int java_lang_AssertionStatusDirectives::packageEnabled_offset; | |
| 2635 int java_lang_AssertionStatusDirectives::deflt_offset; | |
| 2636 int java_nio_Buffer::_limit_offset; | |
| 2637 int sun_misc_AtomicLongCSImpl::_value_offset; | |
| 2638 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0; | |
| 2639 int sun_reflect_ConstantPool::_cp_oop_offset; | |
| 2640 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset; | |
| 2641 | |
| 2642 | |
| 2643 // Support for java_lang_StackTraceElement | |
| 2644 | |
| 2645 void java_lang_StackTraceElement::set_fileName(oop element, oop value) { | |
| 2646 element->obj_field_put(fileName_offset, value); | |
| 2647 } | |
| 2648 | |
| 2649 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) { | |
| 2650 element->obj_field_put(declaringClass_offset, value); | |
| 2651 } | |
| 2652 | |
| 2653 void java_lang_StackTraceElement::set_methodName(oop element, oop value) { | |
| 2654 element->obj_field_put(methodName_offset, value); | |
| 2655 } | |
| 2656 | |
| 2657 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) { | |
| 2658 element->int_field_put(lineNumber_offset, value); | |
| 2659 } | |
| 2660 | |
| 2661 | |
| 2662 // Support for java Assertions - java_lang_AssertionStatusDirectives. | |
| 2663 | |
| 2664 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) { | |
| 2665 o->obj_field_put(classes_offset, val); | |
| 2666 } | |
| 2667 | |
| 2668 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) { | |
| 2669 o->obj_field_put(classEnabled_offset, val); | |
| 2670 } | |
| 2671 | |
| 2672 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) { | |
| 2673 o->obj_field_put(packages_offset, val); | |
| 2674 } | |
| 2675 | |
| 2676 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) { | |
| 2677 o->obj_field_put(packageEnabled_offset, val); | |
| 2678 } | |
| 2679 | |
| 2680 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) { | |
| 2681 o->bool_field_put(deflt_offset, val); | |
| 2682 } | |
| 2683 | |
| 2684 | |
| 2685 // Support for intrinsification of java.nio.Buffer.checkIndex | |
| 2686 int java_nio_Buffer::limit_offset() { | |
| 2687 return _limit_offset; | |
| 2688 } | |
| 2689 | |
| 2690 | |
| 2691 void java_nio_Buffer::compute_offsets() { | |
| 2692 klassOop k = SystemDictionary::java_nio_Buffer_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2693 assert(k != NULL, "must be loaded in 1.4+"); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2694 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); |
| 0 | 2695 } |
| 2696 | |
| 2697 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate | |
| 2698 int sun_misc_AtomicLongCSImpl::value_offset() { | |
| 2699 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this"); | |
| 2700 return _value_offset; | |
| 2701 } | |
| 2702 | |
| 2703 | |
| 2704 void sun_misc_AtomicLongCSImpl::compute_offsets() { | |
| 2705 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass(); | |
| 2706 // If this class is not present, its value field offset won't be referenced. | |
| 2707 if (k != NULL) { | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2708 compute_offset(_value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature()); |
| 0 | 2709 } |
| 2710 } | |
| 2711 | |
| 2712 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) { | |
| 2713 if (_owner_offset != 0) return; | |
| 2714 | |
| 2715 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); | |
| 2716 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); | |
| 2717 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass(); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2718 compute_offset(_owner_offset, k, |
| 0 | 2719 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); |
| 2720 } | |
| 2721 | |
| 2722 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) { | |
| 2723 assert(_owner_offset != 0, "Must be initialized"); | |
| 2724 return obj->obj_field(_owner_offset); | |
| 2725 } | |
| 2726 | |
| 2727 // Compute hard-coded offsets | |
| 2728 // Invoked before SystemDictionary::initialize, so pre-loaded classes | |
| 2729 // are not available to determine the offset_of_static_fields. | |
| 2730 void JavaClasses::compute_hard_coded_offsets() { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
98
diff
changeset
|
2731 const int x = heapOopSize; |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2732 const int header = instanceOopDesc::base_offset_in_bytes(); |
| 0 | 2733 |
| 2734 // Do the String Class | |
| 2735 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header; | |
| 2736 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header; | |
| 2737 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint); | |
| 2738 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint); | |
| 2739 | |
| 2740 // Do the Class Class | |
| 2741 java_lang_Class::klass_offset = java_lang_Class::hc_klass_offset * x + header; | |
| 2742 java_lang_Class::array_klass_offset = java_lang_Class::hc_array_klass_offset * x + header; | |
| 2743 java_lang_Class::resolved_constructor_offset = java_lang_Class::hc_resolved_constructor_offset * x + header; | |
| 2744 | |
| 2745 // This is NOT an offset | |
| 2746 java_lang_Class::number_of_fake_oop_fields = java_lang_Class::hc_number_of_fake_oop_fields; | |
| 2747 | |
| 2748 // Throwable Class | |
| 2749 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header; | |
| 2750 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header; | |
| 2751 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header; | |
| 2752 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header; | |
| 2753 | |
| 2754 // java_lang_boxing_object | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2755 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header; |
|
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2756 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong); |
| 0 | 2757 |
| 2758 // java_lang_ref_Reference: | |
| 2759 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header; | |
| 2760 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header; | |
| 2761 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header; | |
| 2762 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header; | |
| 2763 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x; | |
| 2764 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x; | |
| 2765 // Artificial fields for java_lang_ref_Reference | |
| 2766 // The first field is for the discovered field added in 1.4 | |
| 2767 java_lang_ref_Reference::number_of_fake_oop_fields = 1; | |
| 2768 | |
| 2769 // java_lang_ref_SoftReference Class | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2770 java_lang_ref_SoftReference::timestamp_offset = align_size_up((java_lang_ref_SoftReference::hc_timestamp_offset * x + header), BytesPerLong); |
| 0 | 2771 // Don't multiply static fields because they are always in wordSize units |
| 2772 java_lang_ref_SoftReference::static_clock_offset = java_lang_ref_SoftReference::hc_static_clock_offset * x; | |
| 2773 | |
| 2774 // java_lang_ClassLoader | |
| 2775 java_lang_ClassLoader::parent_offset = java_lang_ClassLoader::hc_parent_offset * x + header; | |
| 2776 | |
| 2777 // java_lang_System | |
| 2778 java_lang_System::static_in_offset = java_lang_System::hc_static_in_offset * x; | |
| 2779 java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x; | |
| 2780 java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x; | |
| 2781 | |
| 2782 // java_lang_StackTraceElement | |
| 2783 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header; | |
| 2784 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header; | |
| 2785 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header; | |
| 2786 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header; | |
| 2787 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header; | |
| 2788 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header; | |
| 2789 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header; | |
| 2790 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header; | |
| 2791 java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header; | |
| 2792 | |
| 2793 } | |
| 2794 | |
| 2795 | |
| 2796 // Compute non-hard-coded field offsets of all the classes in this file | |
| 2797 void JavaClasses::compute_offsets() { | |
| 2798 | |
| 2799 java_lang_Class::compute_offsets(); | |
| 2800 java_lang_System::compute_offsets(); | |
| 2801 java_lang_Thread::compute_offsets(); | |
| 2802 java_lang_ThreadGroup::compute_offsets(); | |
| 710 | 2803 if (EnableMethodHandles) { |
| 2804 java_dyn_MethodHandle::compute_offsets(); | |
| 2805 sun_dyn_MemberName::compute_offsets(); | |
| 2806 sun_dyn_DirectMethodHandle::compute_offsets(); | |
| 2807 sun_dyn_BoundMethodHandle::compute_offsets(); | |
| 2808 sun_dyn_AdapterMethodHandle::compute_offsets(); | |
| 2809 java_dyn_MethodType::compute_offsets(); | |
| 2810 java_dyn_MethodTypeForm::compute_offsets(); | |
| 2811 } | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2812 if (EnableInvokeDynamic) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2813 sun_dyn_CallSiteImpl::compute_offsets(); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2814 } |
| 0 | 2815 java_security_AccessControlContext::compute_offsets(); |
| 2816 // Initialize reflection classes. The layouts of these classes | |
| 2817 // changed with the new reflection implementation in JDK 1.4, and | |
| 2818 // since the Universe doesn't know what JDK version it is until this | |
| 2819 // point we defer computation of these offsets until now. | |
| 2820 java_lang_reflect_AccessibleObject::compute_offsets(); | |
| 2821 java_lang_reflect_Method::compute_offsets(); | |
| 2822 java_lang_reflect_Constructor::compute_offsets(); | |
| 2823 java_lang_reflect_Field::compute_offsets(); | |
| 2824 if (JDK_Version::is_gte_jdk14x_version()) { | |
| 2825 java_nio_Buffer::compute_offsets(); | |
| 2826 } | |
| 2827 if (JDK_Version::is_gte_jdk15x_version()) { | |
| 2828 sun_reflect_ConstantPool::compute_offsets(); | |
| 2829 sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets(); | |
| 2830 } | |
| 2831 sun_misc_AtomicLongCSImpl::compute_offsets(); | |
| 710 | 2832 |
| 2833 // generated interpreter code wants to know about the offsets we just computed: | |
| 2834 AbstractAssembler::update_delayed_values(); | |
| 0 | 2835 } |
| 2836 | |
| 2837 #ifndef PRODUCT | |
| 2838 | |
| 2839 // These functions exist to assert the validity of hard-coded field offsets to guard | |
| 2840 // against changes in the class files | |
| 2841 | |
| 2842 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { | |
| 2843 EXCEPTION_MARK; | |
| 2844 fieldDescriptor fd; | |
| 2845 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH); | |
| 2846 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); | |
| 2847 instanceKlassHandle h_klass (THREAD, k); | |
| 2848 //instanceKlassHandle h_klass(klass); | |
| 2849 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH); | |
| 2850 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH); | |
| 2851 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) { | |
| 2852 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name); | |
| 2853 return false; | |
| 2854 } | |
| 2855 if (fd.is_static()) { | |
| 2856 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name); | |
| 2857 return false; | |
| 2858 } | |
| 2859 if (fd.offset() == hardcoded_offset ) { | |
| 2860 return true; | |
| 2861 } else { | |
| 2862 tty->print_cr("Offset of nonstatic field %s.%s is hardcoded as %d but should really be %d.", | |
| 2863 klass_name, field_name, hardcoded_offset, fd.offset()); | |
| 2864 return false; | |
| 2865 } | |
| 2866 } | |
| 2867 | |
| 2868 | |
| 2869 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { | |
| 2870 EXCEPTION_MARK; | |
| 2871 fieldDescriptor fd; | |
| 2872 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH); | |
| 2873 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); | |
| 2874 instanceKlassHandle h_klass (THREAD, k); | |
| 2875 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH); | |
| 2876 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH); | |
| 2877 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) { | |
| 2878 tty->print_cr("Static field %s.%s not found", klass_name, field_name); | |
| 2879 return false; | |
| 2880 } | |
| 2881 if (!fd.is_static()) { | |
| 2882 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name); | |
| 2883 return false; | |
| 2884 } | |
| 2885 if (fd.offset() == hardcoded_offset + h_klass->offset_of_static_fields()) { | |
| 2886 return true; | |
| 2887 } else { | |
| 2888 tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - h_klass->offset_of_static_fields()); | |
| 2889 return false; | |
| 2890 } | |
| 2891 } | |
| 2892 | |
| 2893 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2894 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2895 EXCEPTION_MARK; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2896 fieldDescriptor fd; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2897 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2898 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2899 instanceKlassHandle h_klass (THREAD, k); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2900 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2901 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2902 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2903 tty->print_cr("Static field %s.%s not found", klass_name, field_name); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2904 return false; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2905 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2906 if (!fd.is_static() || !fd.has_initial_value()) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2907 tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2908 return false; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2909 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2910 if (!fd.initial_value_tag().is_int()) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2911 tty->print_cr("Static field %s.%s is not an int", klass_name, field_name); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2912 return false; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2913 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2914 jint field_value = fd.int_initial_value(); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2915 if (field_value == hardcoded_constant) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2916 return true; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2917 } else { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2918 tty->print_cr("Constant value of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_constant, field_value); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2919 return false; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2920 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2921 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2922 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2923 |
| 0 | 2924 // Check the hard-coded field offsets of all the classes in this file |
| 2925 | |
| 2926 void JavaClasses::check_offsets() { | |
| 2927 bool valid = true; | |
| 2928 | |
| 2929 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ | |
| 2930 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) | |
| 2931 | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2932 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ |
|
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2933 valid &= check_offset(klass_name, cpp_klass_name :: long_ ## field_name ## _offset, #field_name, field_sig) |
|
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2934 |
| 0 | 2935 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ |
| 2936 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig) | |
| 2937 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2938 #define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2939 valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig) |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
2940 |
| 0 | 2941 // java.lang.String |
| 2942 | |
| 2943 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C"); | |
| 2944 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I"); | |
| 2945 CHECK_OFFSET("java/lang/String", java_lang_String, count, "I"); | |
| 2946 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I"); | |
| 2947 | |
| 2948 // java.lang.Class | |
| 2949 | |
| 2950 // Fake fields | |
| 2951 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked | |
| 2952 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked | |
| 2953 // CHECK_OFFSET("java/lang/Class", java_lang_Class, resolved_constructor); // %%% this needs to be checked | |
| 2954 | |
| 2955 // java.lang.Throwable | |
| 2956 | |
| 2957 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;"); | |
| 2958 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;"); | |
| 2959 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;"); | |
| 2960 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;"); | |
| 2961 | |
| 2962 // Boxed primitive objects (java_lang_boxing_object) | |
| 2963 | |
| 2964 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z"); | |
| 2965 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C"); | |
| 2966 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F"); | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2967 CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D"); |
| 0 | 2968 CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B"); |
| 2969 CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S"); | |
| 2970 CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I"); | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
2971 CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J"); |
| 0 | 2972 |
| 2973 // java.lang.ClassLoader | |
| 2974 | |
| 2975 CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent, "Ljava/lang/ClassLoader;"); | |
| 2976 | |
| 2977 // java.lang.System | |
| 2978 | |
| 2979 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, in, "Ljava/io/InputStream;"); | |
| 2980 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;"); | |
| 2981 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, err, "Ljava/io/PrintStream;"); | |
| 2982 | |
| 2983 // java.lang.StackTraceElement | |
| 2984 | |
| 2985 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, declaringClass, "Ljava/lang/String;"); | |
| 2986 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, methodName, "Ljava/lang/String;"); | |
| 2987 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, fileName, "Ljava/lang/String;"); | |
| 2988 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, lineNumber, "I"); | |
| 2989 | |
| 2990 // java.lang.ref.Reference | |
| 2991 | |
| 2992 CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, referent, "Ljava/lang/Object;"); | |
| 2993 CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, queue, "Ljava/lang/ref/ReferenceQueue;"); | |
| 2994 CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, next, "Ljava/lang/ref/Reference;"); | |
| 2995 // Fake field | |
| 2996 //CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, discovered, "Ljava/lang/ref/Reference;"); | |
| 2997 CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, lock, "Ljava/lang/ref/Reference$Lock;"); | |
| 2998 CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, pending, "Ljava/lang/ref/Reference;"); | |
| 2999 | |
| 3000 // java.lang.ref.SoftReference | |
| 3001 | |
| 3002 CHECK_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, timestamp, "J"); | |
| 3003 CHECK_STATIC_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, clock, "J"); | |
| 3004 | |
| 3005 // java.lang.AssertionStatusDirectives | |
| 3006 // | |
| 3007 // The CheckAssertionStatusDirectives boolean can be removed from here and | |
| 3008 // globals.hpp after the AssertionStatusDirectives class has been integrated | |
| 3009 // into merlin "for some time." Without it, the vm will fail with early | |
| 3010 // merlin builds. | |
| 3011 | |
| 3012 if (CheckAssertionStatusDirectives && JDK_Version::is_gte_jdk14x_version()) { | |
| 3013 const char* nm = "java/lang/AssertionStatusDirectives"; | |
| 3014 const char* sig = "[Ljava/lang/String;"; | |
| 3015 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classes, sig); | |
| 3016 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classEnabled, "[Z"); | |
| 3017 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packages, sig); | |
| 3018 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packageEnabled, "[Z"); | |
| 3019 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, deflt, "Z"); | |
| 3020 } | |
| 3021 | |
| 3022 if (!valid) vm_exit_during_initialization("Hard-coded field offset verification failed"); | |
| 3023 } | |
| 3024 | |
| 3025 #endif // PRODUCT | |
| 3026 | |
| 3027 void javaClasses_init() { | |
| 3028 JavaClasses::compute_offsets(); | |
| 3029 JavaClasses::check_offsets(); | |
| 3030 FilteredFieldsMap::initialize(); // must be done after computing offsets. | |
| 3031 } |