Mercurial > hg > truffle
annotate src/share/vm/classfile/javaClasses.hpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | da91efe96a93 |
| children | 80e866b1d053 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 6057 | 2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_CLASSFILE_JAVACLASSES_HPP |
| 26 #define SHARE_VM_CLASSFILE_JAVACLASSES_HPP | |
| 27 | |
| 28 #include "classfile/systemDictionary.hpp" | |
| 29 #include "jvmtifiles/jvmti.h" | |
| 30 #include "oops/oop.hpp" | |
| 31 #include "runtime/os.hpp" | |
| 32 #include "utilities/utf8.hpp" | |
| 33 | |
| 0 | 34 // Interface for manipulating the basic Java classes. |
| 35 // | |
| 36 // All dependencies on layout of actual Java classes should be kept here. | |
| 37 // If the layout of any of the classes above changes the offsets must be adjusted. | |
| 38 // | |
| 39 // For most classes we hardwire the offsets for performance reasons. In certain | |
| 40 // cases (e.g. java.security.AccessControlContext) we compute the offsets at | |
| 41 // startup since the layout here differs between JDK1.2 and JDK1.3. | |
| 42 // | |
| 43 // Note that fields (static and non-static) are arranged with oops before non-oops | |
| 44 // on a per class basis. The offsets below have to reflect this ordering. | |
| 45 // | |
| 46 // When editing the layouts please update the check_offset verification code | |
| 47 // correspondingly. The names in the enums must be identical to the actual field | |
| 48 // names in order for the verification code to work. | |
| 49 | |
| 50 | |
| 51 // Interface to java.lang.String objects | |
| 52 | |
| 53 class java_lang_String : AllStatic { | |
| 54 private: | |
| 55 static int value_offset; | |
| 56 static int offset_offset; | |
| 57 static int count_offset; | |
| 58 static int hash_offset; | |
| 59 | |
| 6057 | 60 static bool initialized; |
| 61 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
62 static Handle basic_create(int length, TRAPS); |
| 0 | 63 |
| 6057 | 64 static void set_value( oop string, typeArrayOop buffer) { |
| 65 assert(initialized, "Must be initialized"); | |
| 66 string->obj_field_put(value_offset, (oop)buffer); | |
| 67 } | |
| 68 static void set_offset(oop string, int offset) { | |
| 69 assert(initialized, "Must be initialized"); | |
| 70 if (offset_offset > 0) { | |
| 71 string->int_field_put(offset_offset, offset); | |
| 72 } | |
| 73 } | |
| 74 static void set_count( oop string, int count) { | |
| 75 assert(initialized, "Must be initialized"); | |
| 76 if (count_offset > 0) { | |
| 77 string->int_field_put(count_offset, count); | |
| 78 } | |
| 79 } | |
| 0 | 80 |
| 81 public: | |
| 6057 | 82 static void compute_offsets(); |
| 83 | |
| 0 | 84 // Instance creation |
| 85 static Handle create_from_unicode(jchar* unicode, int len, TRAPS); | |
| 86 static oop create_oop_from_unicode(jchar* unicode, int len, TRAPS); | |
| 87 static Handle create_from_str(const char* utf8_str, TRAPS); | |
| 88 static oop create_oop_from_str(const char* utf8_str, TRAPS); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
89 static Handle create_from_symbol(Symbol* symbol, TRAPS); |
| 0 | 90 static Handle create_from_platform_dependent_str(const char* str, TRAPS); |
| 91 static Handle char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS); | |
| 92 | |
| 6057 | 93 static bool has_offset_field() { |
| 94 assert(initialized, "Must be initialized"); | |
| 95 return (offset_offset > 0); | |
| 96 } | |
| 97 | |
| 98 static bool has_count_field() { | |
| 99 assert(initialized, "Must be initialized"); | |
| 100 return (count_offset > 0); | |
| 101 } | |
| 102 | |
| 103 static bool has_hash_field() { | |
| 104 assert(initialized, "Must be initialized"); | |
| 105 return (hash_offset > 0); | |
| 106 } | |
| 107 | |
| 108 static int value_offset_in_bytes() { | |
| 109 assert(initialized && (value_offset > 0), "Must be initialized"); | |
| 110 return value_offset; | |
| 111 } | |
| 112 static int count_offset_in_bytes() { | |
| 113 assert(initialized && (count_offset > 0), "Must be initialized"); | |
| 114 return count_offset; | |
| 115 } | |
| 116 static int offset_offset_in_bytes() { | |
| 117 assert(initialized && (offset_offset > 0), "Must be initialized"); | |
| 118 return offset_offset; | |
| 119 } | |
| 120 static int hash_offset_in_bytes() { | |
| 121 assert(initialized && (hash_offset > 0), "Must be initialized"); | |
| 122 return hash_offset; | |
| 123 } | |
| 0 | 124 |
| 125 // Accessors | |
| 126 static typeArrayOop value(oop java_string) { | |
| 6057 | 127 assert(initialized && (value_offset > 0), "Must be initialized"); |
| 0 | 128 assert(is_instance(java_string), "must be java_string"); |
| 129 return (typeArrayOop) java_string->obj_field(value_offset); | |
| 130 } | |
| 131 static int offset(oop java_string) { | |
| 6057 | 132 assert(initialized, "Must be initialized"); |
| 0 | 133 assert(is_instance(java_string), "must be java_string"); |
| 6057 | 134 if (offset_offset > 0) { |
| 135 return java_string->int_field(offset_offset); | |
| 136 } else { | |
| 137 return 0; | |
| 138 } | |
| 0 | 139 } |
| 140 static int length(oop java_string) { | |
| 6057 | 141 assert(initialized, "Must be initialized"); |
| 0 | 142 assert(is_instance(java_string), "must be java_string"); |
| 6057 | 143 if (count_offset > 0) { |
| 144 return java_string->int_field(count_offset); | |
| 145 } else { | |
| 146 return ((typeArrayOop)java_string->obj_field(value_offset))->length(); | |
| 147 } | |
| 0 | 148 } |
| 149 static int utf8_length(oop java_string); | |
| 150 | |
| 151 // String converters | |
| 152 static char* as_utf8_string(oop java_string); | |
|
1989
017cd8bce8a8
6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents:
1972
diff
changeset
|
153 static char* as_utf8_string(oop java_string, char* buf, int buflen); |
| 0 | 154 static char* as_utf8_string(oop java_string, int start, int len); |
|
22
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
155 static char* as_platform_dependent_str(Handle java_string, TRAPS); |
| 0 | 156 static jchar* as_unicode_string(oop java_string, int& length); |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
157 // produce an ascii string with all other values quoted using \u#### |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
158 static char* as_quoted_ascii(oop java_string); |
| 0 | 159 |
|
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
160 // Compute the hash value for a java.lang.String object which would |
| 6162 | 161 // contain the characters passed in. |
|
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
162 // |
| 6162 | 163 // As the hash value used by the String object itself, in |
| 164 // String.hashCode(). This value is normally calculated in Java code | |
| 165 // in the String.hashCode method(), but is precomputed for String | |
| 166 // objects in the shared archive file. | |
| 167 // hash P(31) from Kernighan & Ritchie | |
|
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
168 // |
| 6162 | 169 // For this reason, THIS ALGORITHM MUST MATCH String.toHash(). |
| 170 template <typename T> static unsigned int to_hash(T* s, int len) { | |
|
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
171 unsigned int h = 0; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
172 while (len-- > 0) { |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
173 h = 31*h + (unsigned int) *s; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
174 s++; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
175 } |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
176 return h; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
177 } |
| 6162 | 178 static unsigned int to_hash(oop java_string); |
| 179 | |
| 180 // This is the string hash code used by the StringTable, which may be | |
| 181 // the same as String.toHash or an alternate hash code. | |
|
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
182 static unsigned int hash_string(oop java_string); |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
183 |
| 0 | 184 static bool equals(oop java_string, jchar* chars, int len); |
| 185 | |
| 186 // Conversion between '.' and '/' formats | |
| 187 static Handle externalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '/', '.', THREAD); } | |
| 188 static Handle internalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '.', '/', THREAD); } | |
| 189 | |
| 190 // Conversion | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
191 static Symbol* as_symbol(Handle java_string, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
192 static Symbol* as_symbol_or_null(oop java_string); |
| 0 | 193 |
| 194 // Testers | |
| 195 static bool is_instance(oop obj) { | |
| 1142 | 196 return obj != NULL && obj->klass() == SystemDictionary::String_klass(); |
| 0 | 197 } |
| 198 | |
| 199 // Debugging | |
| 200 static void print(Handle java_string, outputStream* st); | |
| 201 friend class JavaClasses; | |
| 202 }; | |
| 203 | |
| 204 | |
| 205 // Interface to java.lang.Class objects | |
| 206 | |
| 3938 | 207 #define CLASS_INJECTED_FIELDS(macro) \ |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
208 macro(java_lang_Class, klass, intptr_signature, false) \ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
209 macro(java_lang_Class, resolved_constructor, intptr_signature, false) \ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
210 macro(java_lang_Class, array_klass, intptr_signature, false) \ |
| 3938 | 211 macro(java_lang_Class, oop_size, int_signature, false) \ |
| 212 macro(java_lang_Class, static_oop_field_count, int_signature, false) | |
| 213 | |
| 0 | 214 class java_lang_Class : AllStatic { |
| 3938 | 215 friend class VMStructs; |
| 216 | |
| 0 | 217 private: |
| 218 // The fake offsets are added by the class loader when java.lang.Class is loaded | |
| 219 | |
| 3938 | 220 static int _klass_offset; |
| 221 static int _resolved_constructor_offset; | |
| 222 static int _array_klass_offset; | |
| 0 | 223 |
| 3938 | 224 static int _oop_size_offset; |
| 225 static int _static_oop_field_count_offset; | |
| 0 | 226 |
| 227 static bool offsets_computed; | |
| 228 static int classRedefinedCount_offset; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
229 static GrowableArray<Klass*>* _fixup_mirror_list; |
| 0 | 230 |
| 231 public: | |
| 3938 | 232 static void compute_offsets(); |
| 233 | |
| 0 | 234 // Instance creation |
| 235 static oop create_mirror(KlassHandle k, TRAPS); | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
236 static void fixup_mirror(KlassHandle k, TRAPS); |
| 0 | 237 static oop create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS); |
| 238 // Conversion | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
239 static Klass* as_Klass(oop java_class); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
240 static void set_klass(oop java_class, Klass* klass); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
241 static BasicType as_BasicType(oop java_class, Klass** reference_klass = NULL); |
| 710 | 242 static BasicType as_BasicType(oop java_class, KlassHandle* reference_klass) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
243 Klass* refk_oop = NULL; |
| 710 | 244 BasicType result = as_BasicType(java_class, &refk_oop); |
| 245 (*reference_klass) = KlassHandle(refk_oop); | |
| 246 return result; | |
| 247 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
248 static Symbol* 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
|
249 static void print_signature(oop java_class, outputStream *st); |
| 0 | 250 // Testing |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
251 static bool is_instance(oop obj) { |
| 1142 | 252 return obj != NULL && obj->klass() == SystemDictionary::Class_klass(); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
253 } |
| 0 | 254 static bool is_primitive(oop java_class); |
| 255 static BasicType primitive_type(oop java_class); | |
| 256 static oop primitive_mirror(BasicType t); | |
| 257 // JVM_NewInstance support | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
258 static Method* resolved_constructor(oop java_class); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
259 static void set_resolved_constructor(oop java_class, Method* constructor); |
| 0 | 260 // JVM_NewArray support |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
261 static Klass* array_klass(oop java_class); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
262 static void set_array_klass(oop java_class, Klass* klass); |
| 0 | 263 // compiler support for class operations |
| 3938 | 264 static int klass_offset_in_bytes() { return _klass_offset; } |
| 265 static int resolved_constructor_offset_in_bytes() { return _resolved_constructor_offset; } | |
| 266 static int array_klass_offset_in_bytes() { return _array_klass_offset; } | |
| 0 | 267 // Support for classRedefinedCount field |
| 268 static int classRedefinedCount(oop the_class_mirror); | |
| 269 static void set_classRedefinedCount(oop the_class_mirror, int value); | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
270 |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
271 static int oop_size(oop java_class); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
272 static void set_oop_size(oop java_class, int size); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
273 static int static_oop_field_count(oop java_class); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
274 static void set_static_oop_field_count(oop java_class, int size); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
275 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
276 static GrowableArray<Klass*>* fixup_mirror_list() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
277 return _fixup_mirror_list; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
278 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
279 static void set_fixup_mirror_list(GrowableArray<Klass*>* v) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
280 _fixup_mirror_list = v; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
281 } |
| 0 | 282 // Debugging |
| 283 friend class JavaClasses; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
284 friend class InstanceKlass; // verification code accesses offsets |
| 0 | 285 friend class ClassFileParser; // access to number_of_fake_fields |
| 286 }; | |
| 287 | |
| 288 // Interface to java.lang.Thread objects | |
| 289 | |
| 290 class java_lang_Thread : AllStatic { | |
| 291 private: | |
| 292 // Note that for this class the layout changed between JDK1.2 and JDK1.3, | |
| 293 // so we compute the offsets at startup rather than hard-wiring them. | |
| 294 static int _name_offset; | |
| 295 static int _group_offset; | |
| 296 static int _contextClassLoader_offset; | |
| 297 static int _inheritedAccessControlContext_offset; | |
| 298 static int _priority_offset; | |
| 299 static int _eetop_offset; | |
| 300 static int _daemon_offset; | |
| 301 static int _stillborn_offset; | |
| 302 static int _stackSize_offset; | |
| 303 static int _tid_offset; | |
| 304 static int _thread_status_offset; | |
| 305 static int _park_blocker_offset; | |
| 306 static int _park_event_offset ; | |
| 307 | |
| 308 static void compute_offsets(); | |
| 309 | |
| 310 public: | |
| 311 // Instance creation | |
| 312 static oop create(); | |
| 313 // Returns the JavaThread associated with the thread obj | |
| 314 static JavaThread* thread(oop java_thread); | |
| 315 // Set JavaThread for instance | |
| 316 static void set_thread(oop java_thread, JavaThread* thread); | |
| 317 // Name | |
| 318 static typeArrayOop name(oop java_thread); | |
| 319 static void set_name(oop java_thread, typeArrayOop name); | |
| 320 // Priority | |
| 321 static ThreadPriority priority(oop java_thread); | |
| 322 static void set_priority(oop java_thread, ThreadPriority priority); | |
| 323 // Thread group | |
| 324 static oop threadGroup(oop java_thread); | |
| 325 // Stillborn | |
| 326 static bool is_stillborn(oop java_thread); | |
| 327 static void set_stillborn(oop java_thread); | |
| 328 // Alive (NOTE: this is not really a field, but provides the correct | |
| 329 // definition without doing a Java call) | |
| 330 static bool is_alive(oop java_thread); | |
| 331 // Daemon | |
| 332 static bool is_daemon(oop java_thread); | |
| 333 static void set_daemon(oop java_thread); | |
| 334 // Context ClassLoader | |
| 335 static oop context_class_loader(oop java_thread); | |
| 336 // Control context | |
| 337 static oop inherited_access_control_context(oop java_thread); | |
| 338 // Stack size hint | |
| 339 static jlong stackSize(oop java_thread); | |
| 340 // Thread ID | |
| 341 static jlong thread_id(oop java_thread); | |
| 342 | |
| 343 // Blocker object responsible for thread parking | |
| 344 static oop park_blocker(oop java_thread); | |
| 345 | |
| 346 // Pointer to type-stable park handler, encoded as jlong. | |
| 347 // Should be set when apparently null | |
| 348 // For details, see unsafe.cpp Unsafe_Unpark | |
| 349 static jlong park_event(oop java_thread); | |
| 350 static bool set_park_event(oop java_thread, jlong ptr); | |
| 351 | |
| 352 // Java Thread Status for JVMTI and M&M use. | |
| 353 // This thread status info is saved in threadStatus field of | |
| 354 // java.lang.Thread java class. | |
| 355 enum ThreadStatus { | |
| 356 NEW = 0, | |
| 357 RUNNABLE = JVMTI_THREAD_STATE_ALIVE + // runnable / running | |
| 358 JVMTI_THREAD_STATE_RUNNABLE, | |
| 359 SLEEPING = JVMTI_THREAD_STATE_ALIVE + // Thread.sleep() | |
| 360 JVMTI_THREAD_STATE_WAITING + | |
| 361 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + | |
| 362 JVMTI_THREAD_STATE_SLEEPING, | |
| 363 IN_OBJECT_WAIT = JVMTI_THREAD_STATE_ALIVE + // Object.wait() | |
| 364 JVMTI_THREAD_STATE_WAITING + | |
| 365 JVMTI_THREAD_STATE_WAITING_INDEFINITELY + | |
| 366 JVMTI_THREAD_STATE_IN_OBJECT_WAIT, | |
| 367 IN_OBJECT_WAIT_TIMED = JVMTI_THREAD_STATE_ALIVE + // Object.wait(long) | |
| 368 JVMTI_THREAD_STATE_WAITING + | |
| 369 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + | |
| 370 JVMTI_THREAD_STATE_IN_OBJECT_WAIT, | |
| 371 PARKED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park() | |
| 372 JVMTI_THREAD_STATE_WAITING + | |
| 373 JVMTI_THREAD_STATE_WAITING_INDEFINITELY + | |
| 374 JVMTI_THREAD_STATE_PARKED, | |
| 375 PARKED_TIMED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park(long) | |
| 376 JVMTI_THREAD_STATE_WAITING + | |
| 377 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + | |
| 378 JVMTI_THREAD_STATE_PARKED, | |
| 379 BLOCKED_ON_MONITOR_ENTER = JVMTI_THREAD_STATE_ALIVE + // (re-)entering a synchronization block | |
| 380 JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER, | |
| 381 TERMINATED = JVMTI_THREAD_STATE_TERMINATED | |
| 382 }; | |
| 383 // Write thread status info to threadStatus field of java.lang.Thread. | |
| 384 static void set_thread_status(oop java_thread_oop, ThreadStatus status); | |
| 385 // Read thread status info from threadStatus field of java.lang.Thread. | |
| 386 static ThreadStatus get_thread_status(oop java_thread_oop); | |
| 387 | |
| 388 static const char* thread_status_name(oop java_thread_oop); | |
| 389 | |
| 390 // Debugging | |
| 391 friend class JavaClasses; | |
| 392 }; | |
| 393 | |
| 394 // Interface to java.lang.ThreadGroup objects | |
| 395 | |
| 396 class java_lang_ThreadGroup : AllStatic { | |
| 397 private: | |
| 398 static int _parent_offset; | |
| 399 static int _name_offset; | |
| 400 static int _threads_offset; | |
| 401 static int _groups_offset; | |
| 402 static int _maxPriority_offset; | |
| 403 static int _destroyed_offset; | |
| 404 static int _daemon_offset; | |
| 405 static int _vmAllowSuspension_offset; | |
| 406 static int _nthreads_offset; | |
| 407 static int _ngroups_offset; | |
| 408 | |
| 409 static void compute_offsets(); | |
| 410 | |
| 411 public: | |
| 412 // parent ThreadGroup | |
| 413 static oop parent(oop java_thread_group); | |
| 414 // name | |
| 415 static typeArrayOop name(oop java_thread_group); | |
| 416 // ("name as oop" accessor is not necessary) | |
| 417 // Number of threads in group | |
| 418 static int nthreads(oop java_thread_group); | |
| 419 // threads | |
| 420 static objArrayOop threads(oop java_thread_group); | |
| 421 // Number of threads in group | |
| 422 static int ngroups(oop java_thread_group); | |
| 423 // groups | |
| 424 static objArrayOop groups(oop java_thread_group); | |
| 425 // maxPriority in group | |
| 426 static ThreadPriority maxPriority(oop java_thread_group); | |
| 427 // Destroyed | |
| 428 static bool is_destroyed(oop java_thread_group); | |
| 429 // Daemon | |
| 430 static bool is_daemon(oop java_thread_group); | |
| 431 // vmAllowSuspension | |
| 432 static bool is_vmAllowSuspension(oop java_thread_group); | |
| 433 // Debugging | |
| 434 friend class JavaClasses; | |
| 435 }; | |
| 436 | |
| 437 | |
| 438 | |
| 439 // Interface to java.lang.Throwable objects | |
| 440 | |
| 441 class java_lang_Throwable: AllStatic { | |
| 442 friend class BacktraceBuilder; | |
| 443 | |
| 444 private: | |
| 445 // Offsets | |
| 446 enum { | |
| 447 hc_backtrace_offset = 0, | |
| 448 hc_detailMessage_offset = 1, | |
| 449 hc_cause_offset = 2, // New since 1.4 | |
| 450 hc_stackTrace_offset = 3 // New since 1.4 | |
| 451 }; | |
|
3820
0b80db433fcb
7046490: Preallocated OOME objects should obey Throwable stack trace protocol
dholmes
parents:
3785
diff
changeset
|
452 enum { |
|
0b80db433fcb
7046490: Preallocated OOME objects should obey Throwable stack trace protocol
dholmes
parents:
3785
diff
changeset
|
453 hc_static_unassigned_stacktrace_offset = 0 // New since 1.7 |
|
0b80db433fcb
7046490: Preallocated OOME objects should obey Throwable stack trace protocol
dholmes
parents:
3785
diff
changeset
|
454 }; |
| 0 | 455 // Trace constants |
| 456 enum { | |
| 457 trace_methods_offset = 0, | |
| 458 trace_bcis_offset = 1, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
459 trace_mirrors_offset = 2, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
460 trace_next_offset = 3, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
461 trace_size = 4, |
| 0 | 462 trace_chunk_size = 32 |
| 463 }; | |
| 464 | |
| 465 static int backtrace_offset; | |
| 466 static int detailMessage_offset; | |
| 467 static int cause_offset; | |
| 468 static int stackTrace_offset; | |
|
3820
0b80db433fcb
7046490: Preallocated OOME objects should obey Throwable stack trace protocol
dholmes
parents:
3785
diff
changeset
|
469 static int static_unassigned_stacktrace_offset; |
| 0 | 470 |
| 471 // Printing | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
472 static char* print_stack_element_to_buffer(Method* method, int bci); |
| 0 | 473 static void print_to_stream(Handle stream, const char* str); |
| 474 // StackTrace (programmatic access, new since 1.4) | |
| 475 static void clear_stacktrace(oop throwable); | |
| 476 // No stack trace available | |
| 477 static const char* no_stack_trace_message(); | |
|
3820
0b80db433fcb
7046490: Preallocated OOME objects should obey Throwable stack trace protocol
dholmes
parents:
3785
diff
changeset
|
478 // Stacktrace (post JDK 1.7.0 to allow immutability protocol to be followed) |
|
0b80db433fcb
7046490: Preallocated OOME objects should obey Throwable stack trace protocol
dholmes
parents:
3785
diff
changeset
|
479 static void set_stacktrace(oop throwable, oop st_element_array); |
|
0b80db433fcb
7046490: Preallocated OOME objects should obey Throwable stack trace protocol
dholmes
parents:
3785
diff
changeset
|
480 static oop unassigned_stacktrace(); |
| 0 | 481 |
| 482 public: | |
| 483 // Backtrace | |
| 484 static oop backtrace(oop throwable); | |
| 485 static void set_backtrace(oop throwable, oop value); | |
| 486 // Needed by JVMTI to filter out this internal field. | |
| 487 static int get_backtrace_offset() { return backtrace_offset;} | |
| 488 static int get_detailMessage_offset() { return detailMessage_offset;} | |
| 489 // Message | |
| 490 static oop message(oop throwable); | |
| 491 static oop message(Handle throwable); | |
| 492 static void set_message(oop throwable, oop value); | |
| 493 // Print stack trace stored in exception by call-back to Java | |
| 494 // Note: this is no longer used in Merlin, but we still suppport | |
| 495 // it for compatibility. | |
| 496 static void print_stack_trace(oop throwable, oop print_stream); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
497 static void print_stack_element(Handle stream, Method* method, int bci); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
498 static void print_stack_element(outputStream *st, Method* method, int bci); |
| 0 | 499 static void print_stack_usage(Handle stream); |
| 500 | |
| 501 // Allocate space for backtrace (created but stack trace not filled in) | |
| 502 static void allocate_backtrace(Handle throwable, TRAPS); | |
| 503 // Fill in current stack trace for throwable with preallocated backtrace (no GC) | |
| 504 static void fill_in_stack_trace_of_preallocated_backtrace(Handle throwable); | |
| 505 // Fill in current stack trace, can cause GC | |
|
3272
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2418
diff
changeset
|
506 static void fill_in_stack_trace(Handle throwable, methodHandle method, TRAPS); |
|
01147d8aac1d
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
2418
diff
changeset
|
507 static void fill_in_stack_trace(Handle throwable, methodHandle method = methodHandle()); |
| 0 | 508 // Programmatic access to stack trace |
| 509 static oop get_stack_trace_element(oop throwable, int index, TRAPS); | |
| 510 static int get_stack_trace_depth(oop throwable, TRAPS); | |
| 511 // Printing | |
| 512 static void print(oop throwable, outputStream* st); | |
| 513 static void print(Handle throwable, outputStream* st); | |
| 514 static void print_stack_trace(oop throwable, outputStream* st); | |
| 515 // Debugging | |
| 516 friend class JavaClasses; | |
| 517 }; | |
| 518 | |
| 519 | |
| 520 // Interface to java.lang.reflect.AccessibleObject objects | |
| 521 | |
| 522 class java_lang_reflect_AccessibleObject: AllStatic { | |
| 523 private: | |
| 524 // Note that to reduce dependencies on the JDK we compute these | |
| 525 // offsets at run-time. | |
| 526 static int override_offset; | |
| 527 | |
| 528 static void compute_offsets(); | |
| 529 | |
| 530 public: | |
| 531 // Accessors | |
| 532 static jboolean override(oop reflect); | |
| 533 static void set_override(oop reflect, jboolean value); | |
| 534 | |
| 535 // Debugging | |
| 536 friend class JavaClasses; | |
| 537 }; | |
| 538 | |
| 539 | |
| 540 // Interface to java.lang.reflect.Method objects | |
| 541 | |
| 542 class java_lang_reflect_Method : public java_lang_reflect_AccessibleObject { | |
| 543 private: | |
| 544 // Note that to reduce dependencies on the JDK we compute these | |
| 545 // offsets at run-time. | |
| 546 static int clazz_offset; | |
| 547 static int name_offset; | |
| 548 static int returnType_offset; | |
| 549 static int parameterTypes_offset; | |
| 550 static int exceptionTypes_offset; | |
| 551 static int slot_offset; | |
| 552 static int modifiers_offset; | |
| 553 static int signature_offset; | |
| 554 static int annotations_offset; | |
| 555 static int parameter_annotations_offset; | |
| 556 static int annotation_default_offset; | |
| 557 | |
| 558 static void compute_offsets(); | |
| 559 | |
| 560 public: | |
| 561 // Allocation | |
| 562 static Handle create(TRAPS); | |
| 563 | |
| 564 // Accessors | |
| 565 static oop clazz(oop reflect); | |
| 566 static void set_clazz(oop reflect, oop value); | |
| 567 | |
| 568 static oop name(oop method); | |
| 569 static void set_name(oop method, oop value); | |
| 570 | |
| 571 static oop return_type(oop method); | |
| 572 static void set_return_type(oop method, oop value); | |
| 573 | |
| 574 static oop parameter_types(oop method); | |
| 575 static void set_parameter_types(oop method, oop value); | |
| 576 | |
| 577 static oop exception_types(oop method); | |
| 578 static void set_exception_types(oop method, oop value); | |
| 579 | |
| 580 static int slot(oop reflect); | |
| 581 static void set_slot(oop reflect, int value); | |
| 582 | |
| 583 static int modifiers(oop method); | |
| 584 static void set_modifiers(oop method, int value); | |
| 585 | |
| 586 static bool has_signature_field(); | |
| 587 static oop signature(oop method); | |
| 588 static void set_signature(oop method, oop value); | |
| 589 | |
| 590 static bool has_annotations_field(); | |
| 591 static oop annotations(oop method); | |
| 592 static void set_annotations(oop method, oop value); | |
| 593 | |
| 594 static bool has_parameter_annotations_field(); | |
| 595 static oop parameter_annotations(oop method); | |
| 596 static void set_parameter_annotations(oop method, oop value); | |
| 597 | |
| 598 static bool has_annotation_default_field(); | |
| 599 static oop annotation_default(oop method); | |
| 600 static void set_annotation_default(oop method, oop value); | |
| 601 | |
| 602 // Debugging | |
| 603 friend class JavaClasses; | |
| 604 }; | |
| 605 | |
| 606 | |
| 607 // Interface to java.lang.reflect.Constructor objects | |
| 608 | |
| 609 class java_lang_reflect_Constructor : public java_lang_reflect_AccessibleObject { | |
| 610 private: | |
| 611 // Note that to reduce dependencies on the JDK we compute these | |
| 612 // offsets at run-time. | |
| 613 static int clazz_offset; | |
| 614 static int parameterTypes_offset; | |
| 615 static int exceptionTypes_offset; | |
| 616 static int slot_offset; | |
| 617 static int modifiers_offset; | |
| 618 static int signature_offset; | |
| 619 static int annotations_offset; | |
| 620 static int parameter_annotations_offset; | |
| 621 | |
| 622 static void compute_offsets(); | |
| 623 | |
| 624 public: | |
| 625 // Allocation | |
| 626 static Handle create(TRAPS); | |
| 627 | |
| 628 // Accessors | |
| 629 static oop clazz(oop reflect); | |
| 630 static void set_clazz(oop reflect, oop value); | |
| 631 | |
| 632 static oop parameter_types(oop constructor); | |
| 633 static void set_parameter_types(oop constructor, oop value); | |
| 634 | |
| 635 static oop exception_types(oop constructor); | |
| 636 static void set_exception_types(oop constructor, oop value); | |
| 637 | |
| 638 static int slot(oop reflect); | |
| 639 static void set_slot(oop reflect, int value); | |
| 640 | |
| 641 static int modifiers(oop constructor); | |
| 642 static void set_modifiers(oop constructor, int value); | |
| 643 | |
| 644 static bool has_signature_field(); | |
| 645 static oop signature(oop constructor); | |
| 646 static void set_signature(oop constructor, oop value); | |
| 647 | |
| 648 static bool has_annotations_field(); | |
| 649 static oop annotations(oop constructor); | |
| 650 static void set_annotations(oop constructor, oop value); | |
| 651 | |
| 652 static bool has_parameter_annotations_field(); | |
| 653 static oop parameter_annotations(oop method); | |
| 654 static void set_parameter_annotations(oop method, oop value); | |
| 655 | |
| 656 // Debugging | |
| 657 friend class JavaClasses; | |
| 658 }; | |
| 659 | |
| 660 | |
| 661 // Interface to java.lang.reflect.Field objects | |
| 662 | |
| 663 class java_lang_reflect_Field : public java_lang_reflect_AccessibleObject { | |
| 664 private: | |
| 665 // Note that to reduce dependencies on the JDK we compute these | |
| 666 // offsets at run-time. | |
| 667 static int clazz_offset; | |
| 668 static int name_offset; | |
| 669 static int type_offset; | |
| 670 static int slot_offset; | |
| 671 static int modifiers_offset; | |
| 672 static int signature_offset; | |
| 673 static int annotations_offset; | |
| 674 | |
| 675 static void compute_offsets(); | |
| 676 | |
| 677 public: | |
| 678 // Allocation | |
| 679 static Handle create(TRAPS); | |
| 680 | |
| 681 // Accessors | |
| 682 static oop clazz(oop reflect); | |
| 683 static void set_clazz(oop reflect, oop value); | |
| 684 | |
| 685 static oop name(oop field); | |
| 686 static void set_name(oop field, oop value); | |
| 687 | |
| 688 static oop type(oop field); | |
| 689 static void set_type(oop field, oop value); | |
| 690 | |
| 691 static int slot(oop reflect); | |
| 692 static void set_slot(oop reflect, int value); | |
| 693 | |
| 694 static int modifiers(oop field); | |
| 695 static void set_modifiers(oop field, int value); | |
| 696 | |
| 697 static bool has_signature_field(); | |
| 698 static oop signature(oop constructor); | |
| 699 static void set_signature(oop constructor, oop value); | |
| 700 | |
| 701 static bool has_annotations_field(); | |
| 702 static oop annotations(oop constructor); | |
| 703 static void set_annotations(oop constructor, oop value); | |
| 704 | |
| 705 static bool has_parameter_annotations_field(); | |
| 706 static oop parameter_annotations(oop method); | |
| 707 static void set_parameter_annotations(oop method, oop value); | |
| 708 | |
| 709 static bool has_annotation_default_field(); | |
| 710 static oop annotation_default(oop method); | |
| 711 static void set_annotation_default(oop method, oop value); | |
| 712 | |
| 713 // Debugging | |
| 714 friend class JavaClasses; | |
| 715 }; | |
| 716 | |
| 717 // Interface to sun.reflect.ConstantPool objects | |
| 718 class sun_reflect_ConstantPool { | |
| 719 private: | |
| 720 // Note that to reduce dependencies on the JDK we compute these | |
| 721 // offsets at run-time. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
722 static int _oop_offset; |
| 0 | 723 |
| 724 static void compute_offsets(); | |
| 725 | |
| 726 public: | |
| 727 // Allocation | |
| 728 static Handle create(TRAPS); | |
| 729 | |
| 730 // Accessors | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
731 static void set_cp(oop reflect, ConstantPool* value); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
732 static int oop_offset() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
733 return _oop_offset; |
| 0 | 734 } |
| 735 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
736 static ConstantPool* get_cp(oop reflect); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
737 |
| 0 | 738 // Debugging |
| 739 friend class JavaClasses; | |
| 740 }; | |
| 741 | |
| 742 // Interface to sun.reflect.UnsafeStaticFieldAccessorImpl objects | |
| 743 class sun_reflect_UnsafeStaticFieldAccessorImpl { | |
| 744 private: | |
| 745 static int _base_offset; | |
| 746 static void compute_offsets(); | |
| 747 | |
| 748 public: | |
| 749 static int base_offset() { | |
| 750 return _base_offset; | |
| 751 } | |
| 752 | |
| 753 // Debugging | |
| 754 friend class JavaClasses; | |
| 755 }; | |
| 756 | |
| 757 // Interface to java.lang primitive type boxing objects: | |
| 758 // - java.lang.Boolean | |
| 759 // - java.lang.Character | |
| 760 // - java.lang.Float | |
| 761 // - java.lang.Double | |
| 762 // - java.lang.Byte | |
| 763 // - java.lang.Short | |
| 764 // - java.lang.Integer | |
| 765 // - java.lang.Long | |
| 766 | |
| 767 // This could be separated out into 8 individual classes. | |
| 768 | |
| 769 class java_lang_boxing_object: AllStatic { | |
| 770 private: | |
| 771 enum { | |
| 772 hc_value_offset = 0 | |
| 773 }; | |
| 774 static int value_offset; | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
775 static int long_value_offset; |
| 0 | 776 |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
777 static oop initialize_and_allocate(BasicType type, TRAPS); |
| 0 | 778 public: |
| 779 // Allocation. Returns a boxed value, or NULL for invalid type. | |
| 780 static oop create(BasicType type, jvalue* value, TRAPS); | |
| 781 // Accessors. Returns the basic type being boxed, or T_ILLEGAL for invalid oop. | |
| 782 static BasicType get_value(oop box, jvalue* value); | |
| 783 static BasicType set_value(oop box, jvalue* value); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
784 static BasicType basic_type(oop box); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
785 static bool is_instance(oop box) { return basic_type(box) != T_ILLEGAL; } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
786 static bool is_instance(oop box, BasicType type) { return basic_type(box) == type; } |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
787 static void print(oop box, outputStream* st) { jvalue value; print(get_value(box, &value), &value, st); } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
788 static void print(BasicType type, jvalue* value, outputStream* st); |
| 0 | 789 |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
790 static int value_offset_in_bytes(BasicType type) { |
|
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
791 return ( type == T_LONG || type == T_DOUBLE ) ? long_value_offset : |
|
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
792 value_offset; |
|
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
793 } |
| 0 | 794 |
| 795 // Debugging | |
| 796 friend class JavaClasses; | |
| 797 }; | |
| 798 | |
| 799 | |
| 800 | |
| 801 // Interface to java.lang.ref.Reference objects | |
| 802 | |
| 803 class java_lang_ref_Reference: AllStatic { | |
| 804 public: | |
| 805 enum { | |
| 806 hc_referent_offset = 0, | |
| 807 hc_queue_offset = 1, | |
| 808 hc_next_offset = 2, | |
| 809 hc_discovered_offset = 3 // Is not last, see SoftRefs. | |
| 810 }; | |
| 811 enum { | |
| 812 hc_static_lock_offset = 0, | |
| 813 hc_static_pending_offset = 1 | |
| 814 }; | |
| 815 | |
| 816 static int referent_offset; | |
| 817 static int queue_offset; | |
| 818 static int next_offset; | |
| 819 static int discovered_offset; | |
| 820 static int static_lock_offset; | |
| 821 static int static_pending_offset; | |
| 822 static int number_of_fake_oop_fields; | |
| 823 | |
| 824 // Accessors | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
825 static oop referent(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
826 return ref->obj_field(referent_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
827 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
828 static void set_referent(oop ref, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
829 ref->obj_field_put(referent_offset, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
830 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
831 static void set_referent_raw(oop ref, oop value) { |
|
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
832 ref->obj_field_put_raw(referent_offset, value); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
833 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
834 static HeapWord* referent_addr(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
835 return ref->obj_field_addr<HeapWord>(referent_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
836 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
837 static oop next(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
838 return ref->obj_field(next_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
839 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
840 static void set_next(oop ref, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
841 ref->obj_field_put(next_offset, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
842 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
843 static void set_next_raw(oop ref, oop value) { |
|
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
844 ref->obj_field_put_raw(next_offset, value); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
845 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
846 static HeapWord* next_addr(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
847 return ref->obj_field_addr<HeapWord>(next_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
848 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
849 static oop discovered(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
850 return ref->obj_field(discovered_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
851 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
852 static void set_discovered(oop ref, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
853 ref->obj_field_put(discovered_offset, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
854 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
855 static void set_discovered_raw(oop ref, oop value) { |
|
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
856 ref->obj_field_put_raw(discovered_offset, value); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
857 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
858 static HeapWord* discovered_addr(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
859 return ref->obj_field_addr<HeapWord>(discovered_offset); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
860 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
861 // Accessors for statics |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
862 static oop pending_list_lock(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
863 static oop pending_list(); |
| 0 | 864 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
865 static HeapWord* pending_list_lock_addr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
866 static HeapWord* pending_list_addr(); |
| 0 | 867 }; |
| 868 | |
| 869 | |
| 870 // Interface to java.lang.ref.SoftReference objects | |
| 871 | |
| 872 class java_lang_ref_SoftReference: public java_lang_ref_Reference { | |
| 873 public: | |
| 874 enum { | |
| 875 // The timestamp is a long field and may need to be adjusted for alignment. | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
876 hc_timestamp_offset = hc_discovered_offset + 1 |
| 0 | 877 }; |
| 878 enum { | |
| 879 hc_static_clock_offset = 0 | |
| 880 }; | |
| 881 | |
| 882 static int timestamp_offset; | |
| 883 static int static_clock_offset; | |
| 884 | |
| 885 // Accessors | |
| 886 static jlong timestamp(oop ref); | |
| 887 | |
| 888 // Accessors for statics | |
| 889 static jlong clock(); | |
| 890 static void set_clock(jlong value); | |
| 891 }; | |
| 892 | |
| 893 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
894 // Interface to java.lang.invoke.MethodHandle objects |
| 710 | 895 |
| 896 class MethodHandleEntry; | |
| 897 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
898 class java_lang_invoke_MethodHandle: AllStatic { |
| 710 | 899 friend class JavaClasses; |
| 900 | |
| 901 private: | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
902 static int _type_offset; // the MethodType of this MH |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
903 static int _form_offset; // the LambdaForm of this MH |
| 710 | 904 |
| 905 static void compute_offsets(); | |
| 906 | |
| 907 public: | |
| 908 // Accessors | |
| 909 static oop type(oop mh); | |
| 910 static void set_type(oop mh, oop mtype); | |
| 911 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
912 static oop form(oop mh); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
913 static void set_form(oop mh, oop lform); |
| 710 | 914 |
| 915 // Testers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
916 static bool is_subclass(Klass* klass) { |
| 710 | 917 return Klass::cast(klass)->is_subclass_of(SystemDictionary::MethodHandle_klass()); |
| 918 } | |
| 919 static bool is_instance(oop obj) { | |
| 920 return obj != NULL && is_subclass(obj->klass()); | |
| 921 } | |
| 922 | |
| 923 // Accessors for code generation: | |
| 924 static int type_offset_in_bytes() { return _type_offset; } | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
925 static int form_offset_in_bytes() { return _form_offset; } |
| 710 | 926 }; |
| 927 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
928 // Interface to java.lang.invoke.LambdaForm objects |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
929 // (These are a private interface for managing adapter code generation.) |
| 3938 | 930 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
931 class java_lang_invoke_LambdaForm: AllStatic { |
| 710 | 932 friend class JavaClasses; |
| 933 | |
| 934 private: | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
935 static int _vmentry_offset; // type is MemberName |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
936 |
| 710 | 937 static void compute_offsets(); |
| 938 | |
| 939 public: | |
| 940 // Accessors | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
941 static oop vmentry(oop lform); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
942 static void set_vmentry(oop lform, oop invoker); |
| 710 | 943 |
| 944 // Testers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
945 static bool is_subclass(Klass* klass) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
946 return SystemDictionary::LambdaForm_klass() != NULL && |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
947 Klass::cast(klass)->is_subclass_of(SystemDictionary::LambdaForm_klass()); |
| 710 | 948 } |
| 949 static bool is_instance(oop obj) { | |
| 950 return obj != NULL && is_subclass(obj->klass()); | |
| 951 } | |
| 952 | |
| 953 // Accessors for code generation: | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
954 static int vmentry_offset_in_bytes() { return _vmentry_offset; } |
| 710 | 955 }; |
| 956 | |
|
3905
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3820
diff
changeset
|
957 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
958 // Interface to java.lang.invoke.MemberName objects |
| 710 | 959 // (These are a private interface for Java code to query the class hierarchy.) |
| 960 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
961 #define MEMBERNAME_INJECTED_FIELDS(macro) \ |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
962 macro(java_lang_invoke_MemberName, vmloader, object_signature, false) \ |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
963 macro(java_lang_invoke_MemberName, vmindex, intptr_signature, false) \ |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
964 macro(java_lang_invoke_MemberName, vmtarget, intptr_signature, false) |
| 3938 | 965 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
966 class java_lang_invoke_MemberName: AllStatic { |
| 710 | 967 friend class JavaClasses; |
| 968 | |
| 969 private: | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
970 // From java.lang.invoke.MemberName: |
| 710 | 971 // private Class<?> clazz; // class in which the method is defined |
| 972 // private String name; // may be null if not yet materialized | |
| 973 // private Object type; // may be null if not yet materialized | |
| 974 // private int flags; // modifier bits; see reflect.Modifier | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
975 // private intptr vmtarget; // VM-specific target value |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
976 // private intptr_t vmindex; // member index within class or interface |
| 710 | 977 static int _clazz_offset; |
| 978 static int _name_offset; | |
| 979 static int _type_offset; | |
| 980 static int _flags_offset; | |
| 981 static int _vmtarget_offset; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
982 static int _vmloader_offset; |
| 710 | 983 static int _vmindex_offset; |
| 984 | |
| 985 static void compute_offsets(); | |
| 986 | |
| 987 public: | |
| 988 // Accessors | |
| 989 static oop clazz(oop mname); | |
| 990 static void set_clazz(oop mname, oop clazz); | |
| 991 | |
| 992 static oop type(oop mname); | |
| 993 static void set_type(oop mname, oop type); | |
| 994 | |
| 995 static oop name(oop mname); | |
| 996 static void set_name(oop mname, oop name); | |
| 997 | |
| 998 static int flags(oop mname); | |
| 999 static void set_flags(oop mname, int flags); | |
| 1000 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1001 static Metadata* vmtarget(oop mname); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1002 static void set_vmtarget(oop mname, Metadata* target); |
| 710 | 1003 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1004 static intptr_t vmindex(oop mname); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1005 static void set_vmindex(oop mname, intptr_t index); |
| 710 | 1006 |
| 1007 // Testers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1008 static bool is_subclass(Klass* klass) { |
| 710 | 1009 return Klass::cast(klass)->is_subclass_of(SystemDictionary::MemberName_klass()); |
| 1010 } | |
| 1011 static bool is_instance(oop obj) { | |
| 1012 return obj != NULL && is_subclass(obj->klass()); | |
| 1013 } | |
| 1014 | |
| 1015 // Relevant integer codes (keep these in synch. with MethodHandleNatives.Constants): | |
| 1016 enum { | |
| 1017 MN_IS_METHOD = 0x00010000, // method (not constructor) | |
| 1018 MN_IS_CONSTRUCTOR = 0x00020000, // constructor | |
| 1019 MN_IS_FIELD = 0x00040000, // field | |
| 1020 MN_IS_TYPE = 0x00080000, // nested type | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1021 MN_REFERENCE_KIND_SHIFT = 24, // refKind |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1022 MN_REFERENCE_KIND_MASK = 0x0F000000 >> MN_REFERENCE_KIND_SHIFT, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1023 // The SEARCH_* bits are not for MN.flags but for the matchFlags argument of MHN.getMembers: |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1024 MN_SEARCH_SUPERCLASSES = 0x00100000, // walk super classes |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1025 MN_SEARCH_INTERFACES = 0x00200000 // walk implemented interfaces |
| 710 | 1026 }; |
| 1027 | |
| 1028 // Accessors for code generation: | |
| 1029 static int clazz_offset_in_bytes() { return _clazz_offset; } | |
| 1030 static int type_offset_in_bytes() { return _type_offset; } | |
| 1031 static int name_offset_in_bytes() { return _name_offset; } | |
| 1032 static int flags_offset_in_bytes() { return _flags_offset; } | |
| 1033 static int vmtarget_offset_in_bytes() { return _vmtarget_offset; } | |
| 1034 static int vmindex_offset_in_bytes() { return _vmindex_offset; } | |
| 1035 }; | |
| 1036 | |
| 1037 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1038 // Interface to java.lang.invoke.MethodType objects |
| 710 | 1039 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1040 class java_lang_invoke_MethodType: AllStatic { |
| 710 | 1041 friend class JavaClasses; |
| 1042 | |
| 1043 private: | |
| 1044 static int _rtype_offset; | |
| 1045 static int _ptypes_offset; | |
| 1046 | |
| 1047 static void compute_offsets(); | |
| 1048 | |
| 1049 public: | |
| 1050 // Accessors | |
| 1051 static oop rtype(oop mt); | |
| 1052 static objArrayOop ptypes(oop mt); | |
| 1053 | |
| 1054 static oop ptype(oop mt, int index); | |
|
1133
aa62b9388fce
6894206: JVM needs a way to traverse method handle structures
twisti
parents:
1059
diff
changeset
|
1055 static int ptype_count(oop mt); |
| 710 | 1056 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1057 static int ptype_slot_count(oop mt); // extra counts for long/double |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1058 static int rtype_slot_count(oop mt); // extra counts for long/double |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1059 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
1060 static Symbol* as_signature(oop mt, bool intern_if_not_found, TRAPS); |
| 710 | 1061 static void print_signature(oop mt, outputStream* st); |
| 1062 | |
| 1063 static bool is_instance(oop obj) { | |
| 1064 return obj != NULL && obj->klass() == SystemDictionary::MethodType_klass(); | |
| 1065 } | |
| 1066 | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3363
diff
changeset
|
1067 static bool equals(oop mt1, oop mt2); |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3363
diff
changeset
|
1068 |
| 710 | 1069 // Accessors for code generation: |
| 1070 static int rtype_offset_in_bytes() { return _rtype_offset; } | |
| 1071 static int ptypes_offset_in_bytes() { return _ptypes_offset; } | |
| 1072 }; | |
| 1073 | |
| 1074 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1075 // Interface to java.lang.invoke.CallSite objects |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1076 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1077 class java_lang_invoke_CallSite: AllStatic { |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1078 friend class JavaClasses; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1079 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1080 private: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1081 static int _target_offset; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1082 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1083 static void compute_offsets(); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1084 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1085 public: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1086 // Accessors |
|
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
1087 static oop target( oop site) { return site->obj_field( _target_offset); } |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
1088 static void set_target( oop site, oop target) { site->obj_field_put( _target_offset, target); } |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
1089 |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
1090 static volatile oop target_volatile(oop site) { return site->obj_field_volatile( _target_offset); } |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
3905
diff
changeset
|
1091 static void set_target_volatile(oop site, oop target) { site->obj_field_put_volatile(_target_offset, target); } |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1092 |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1093 // Testers |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1094 static bool is_subclass(Klass* klass) { |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1095 return Klass::cast(klass)->is_subclass_of(SystemDictionary::CallSite_klass()); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1096 } |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1097 static bool is_instance(oop obj) { |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1098 return obj != NULL && is_subclass(obj->klass()); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1099 } |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1100 |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1101 // Accessors for code generation: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1102 static int target_offset_in_bytes() { return _target_offset; } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1103 }; |
| 710 | 1104 |
| 1105 | |
| 0 | 1106 // Interface to java.security.AccessControlContext objects |
| 1107 | |
| 1108 class java_security_AccessControlContext: AllStatic { | |
| 1109 private: | |
| 1110 // Note that for this class the layout changed between JDK1.2 and JDK1.3, | |
| 1111 // so we compute the offsets at startup rather than hard-wiring them. | |
| 1112 static int _context_offset; | |
| 1113 static int _privilegedContext_offset; | |
| 1114 static int _isPrivileged_offset; | |
| 1115 | |
| 1116 static void compute_offsets(); | |
| 1117 public: | |
| 1118 static oop create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS); | |
| 1119 | |
| 1120 // Debugging/initialization | |
| 1121 friend class JavaClasses; | |
| 1122 }; | |
| 1123 | |
| 1124 | |
| 1125 // Interface to java.lang.ClassLoader objects | |
| 1126 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1127 #define CLASSLOADER_INJECTED_FIELDS(macro) \ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1128 macro(java_lang_ClassLoader, loader_data, intptr_signature, false) \ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1129 macro(java_lang_ClassLoader, dependencies, object_signature, false) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1130 |
| 0 | 1131 class java_lang_ClassLoader : AllStatic { |
| 1132 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1133 // The fake offsets are added by the class loader when java.lang.Class is loaded |
| 0 | 1134 enum { |
| 1135 hc_parent_offset = 0 | |
| 1136 }; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1137 static int _loader_data_offset; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1138 static int _dependencies_offset; |
| 3938 | 1139 static bool offsets_computed; |
| 0 | 1140 static int parent_offset; |
| 3938 | 1141 static int parallelCapable_offset; |
| 1142 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1143 public: |
| 3938 | 1144 static void compute_offsets(); |
| 0 | 1145 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1146 static ClassLoaderData** loader_data_addr(oop loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1147 static ClassLoaderData* loader_data(oop loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1148 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1149 static oop dependencies(oop loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1150 static HeapWord* dependencies_addr(oop loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1151 |
| 0 | 1152 static oop parent(oop loader); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1153 static bool isAncestor(oop loader, oop cl); |
| 0 | 1154 |
| 3938 | 1155 // Support for parallelCapable field |
| 1156 static bool parallelCapable(oop the_class_mirror); | |
| 1157 | |
| 0 | 1158 static bool is_trusted_loader(oop loader); |
| 1159 | |
| 1160 // Fix for 4474172 | |
| 1161 static oop non_reflection_class_loader(oop loader); | |
| 1162 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1163 // Testers |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1164 static bool is_subclass(Klass* klass) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1165 return Klass::cast(klass)->is_subclass_of(SystemDictionary::ClassLoader_klass()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1166 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1167 static bool is_instance(oop obj) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1168 return obj != NULL && is_subclass(obj->klass()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1169 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1170 |
| 0 | 1171 // Debugging |
| 1172 friend class JavaClasses; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1173 friend class ClassFileParser; // access to number_of_fake_fields |
| 0 | 1174 }; |
| 1175 | |
| 1176 | |
| 1177 // Interface to java.lang.System objects | |
| 1178 | |
| 1179 class java_lang_System : AllStatic { | |
| 1180 private: | |
| 1181 enum { | |
| 1182 hc_static_in_offset = 0, | |
| 1183 hc_static_out_offset = 1, | |
| 1184 hc_static_err_offset = 2 | |
| 1185 }; | |
| 1186 | |
| 1187 static int static_in_offset; | |
| 1188 static int static_out_offset; | |
| 1189 static int static_err_offset; | |
| 1190 | |
| 1191 public: | |
| 1192 static int in_offset_in_bytes(); | |
| 1193 static int out_offset_in_bytes(); | |
| 1194 static int err_offset_in_bytes(); | |
| 1195 | |
| 1196 // Debugging | |
| 1197 friend class JavaClasses; | |
| 1198 }; | |
| 1199 | |
| 1200 | |
| 1201 // Interface to java.lang.StackTraceElement objects | |
| 1202 | |
| 1203 class java_lang_StackTraceElement: AllStatic { | |
| 1204 private: | |
| 1205 enum { | |
| 1206 hc_declaringClass_offset = 0, | |
| 1207 hc_methodName_offset = 1, | |
| 1208 hc_fileName_offset = 2, | |
| 1209 hc_lineNumber_offset = 3 | |
| 1210 }; | |
| 1211 | |
| 1212 static int declaringClass_offset; | |
| 1213 static int methodName_offset; | |
| 1214 static int fileName_offset; | |
| 1215 static int lineNumber_offset; | |
| 1216 | |
| 1217 public: | |
| 1218 // Setters | |
| 1219 static void set_declaringClass(oop element, oop value); | |
| 1220 static void set_methodName(oop element, oop value); | |
| 1221 static void set_fileName(oop element, oop value); | |
| 1222 static void set_lineNumber(oop element, int value); | |
| 1223 | |
| 1224 // Create an instance of StackTraceElement | |
| 1225 static oop create(methodHandle m, int bci, TRAPS); | |
| 1226 | |
| 1227 // Debugging | |
| 1228 friend class JavaClasses; | |
| 1229 }; | |
| 1230 | |
| 1231 | |
| 1232 // Interface to java.lang.AssertionStatusDirectives objects | |
| 1233 | |
| 1234 class java_lang_AssertionStatusDirectives: AllStatic { | |
| 1235 private: | |
| 1236 enum { | |
| 1237 hc_classes_offset, | |
| 1238 hc_classEnabled_offset, | |
| 1239 hc_packages_offset, | |
| 1240 hc_packageEnabled_offset, | |
| 1241 hc_deflt_offset | |
| 1242 }; | |
| 1243 | |
| 1244 static int classes_offset; | |
| 1245 static int classEnabled_offset; | |
| 1246 static int packages_offset; | |
| 1247 static int packageEnabled_offset; | |
| 1248 static int deflt_offset; | |
| 1249 | |
| 1250 public: | |
| 1251 // Setters | |
| 1252 static void set_classes(oop obj, oop val); | |
| 1253 static void set_classEnabled(oop obj, oop val); | |
| 1254 static void set_packages(oop obj, oop val); | |
| 1255 static void set_packageEnabled(oop obj, oop val); | |
| 1256 static void set_deflt(oop obj, bool val); | |
| 1257 // Debugging | |
| 1258 friend class JavaClasses; | |
| 1259 }; | |
| 1260 | |
| 1261 | |
| 1262 class java_nio_Buffer: AllStatic { | |
| 1263 private: | |
| 1264 static int _limit_offset; | |
| 1265 | |
| 1266 public: | |
| 1267 static int limit_offset(); | |
| 1268 static void compute_offsets(); | |
| 1269 }; | |
| 1270 | |
| 1271 class java_util_concurrent_locks_AbstractOwnableSynchronizer : AllStatic { | |
| 1272 private: | |
| 1273 static int _owner_offset; | |
| 1274 public: | |
| 1275 static void initialize(TRAPS); | |
| 1276 static oop get_owner_threadObj(oop obj); | |
| 1277 }; | |
| 1278 | |
| 3938 | 1279 // Use to declare fields that need to be injected into Java classes |
| 1280 // for the JVM to use. The name_index and signature_index are | |
| 1281 // declared in vmSymbols. The may_be_java flag is used to declare | |
| 1282 // fields that might already exist in Java but should be injected if | |
| 1283 // they don't. Otherwise the field is unconditionally injected and | |
| 1284 // the JVM uses the injected one. This is to ensure that name | |
| 1285 // collisions don't occur. In general may_be_java should be false | |
| 1286 // unless there's a good reason. | |
| 1287 | |
| 1288 class InjectedField { | |
| 1289 public: | |
| 1290 const SystemDictionary::WKID klass_id; | |
| 1291 const vmSymbols::SID name_index; | |
| 1292 const vmSymbols::SID signature_index; | |
| 1293 const bool may_be_java; | |
| 1294 | |
| 1295 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1296 Klass* klass() const { return SystemDictionary::well_known_klass(klass_id); } |
| 3938 | 1297 Symbol* name() const { return lookup_symbol(name_index); } |
| 1298 Symbol* signature() const { return lookup_symbol(signature_index); } | |
| 1299 | |
| 1300 int compute_offset(); | |
| 1301 | |
| 1302 // Find the Symbol for this index | |
| 1303 static Symbol* lookup_symbol(int symbol_index) { | |
| 1304 return vmSymbols::symbol_at((vmSymbols::SID)symbol_index); | |
| 1305 } | |
| 1306 }; | |
| 1307 | |
| 1308 #define DECLARE_INJECTED_FIELD_ENUM(klass, name, signature, may_be_java) \ | |
| 1309 klass##_##name##_enum, | |
| 1310 | |
| 1311 #define ALL_INJECTED_FIELDS(macro) \ | |
| 1312 CLASS_INJECTED_FIELDS(macro) \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1313 CLASSLOADER_INJECTED_FIELDS(macro) \ |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6166
diff
changeset
|
1314 MEMBERNAME_INJECTED_FIELDS(macro) |
| 3938 | 1315 |
| 0 | 1316 // Interface to hard-coded offset checking |
| 1317 | |
| 1318 class JavaClasses : AllStatic { | |
| 1319 private: | |
| 3938 | 1320 |
| 1321 static InjectedField _injected_fields[]; | |
| 1322 | |
| 0 | 1323 static bool check_offset(const char *klass_name, int offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0; |
| 1324 static bool check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0; | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
1325 static bool check_constant(const char *klass_name, int constant, const char *field_name, const char* field_sig) PRODUCT_RETURN0; |
| 3938 | 1326 |
| 0 | 1327 public: |
| 3938 | 1328 enum InjectedFieldID { |
| 1329 ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD_ENUM) | |
| 1330 MAX_enum | |
| 1331 }; | |
| 1332 | |
| 1333 static int compute_injected_offset(InjectedFieldID id); | |
| 1334 | |
| 0 | 1335 static void compute_hard_coded_offsets(); |
| 1336 static void compute_offsets(); | |
| 1337 static void check_offsets() PRODUCT_RETURN; | |
| 3938 | 1338 |
| 1339 static InjectedField* get_injected(Symbol* class_name, int* field_count); | |
| 0 | 1340 }; |
| 1972 | 1341 |
| 3938 | 1342 #undef DECLARE_INJECTED_FIELD_ENUM |
| 1343 | |
| 1972 | 1344 #endif // SHARE_VM_CLASSFILE_JAVACLASSES_HPP |