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