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