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