Mercurial > hg > graal-compiler
annotate src/share/vm/classfile/javaClasses.hpp @ 2607:008adfd6d850
Fixed the stateBefore of invokes and monitorenter instructions to include the arguments of the instruction.
This is necessary to ensure correct continuation in the interpreter when the stateBefore is used as a deoptimization point.
| author | Thomas Wuerthinger <thomas@wuerthinger.net> |
|---|---|
| date | Fri, 06 May 2011 17:47:17 +0200 |
| parents | 352622fd140a |
| children | 01147d8aac1d |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #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 enum { | |
| 56 hc_value_offset = 0, | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
57 hc_offset_offset = 1 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
58 //hc_count_offset = 2 -- not a word-scaled offset |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
59 //hc_hash_offset = 3 -- not a word-scaled offset |
| 0 | 60 }; |
| 61 | |
| 62 static int value_offset; | |
| 63 static int offset_offset; | |
| 64 static int count_offset; | |
| 65 static int hash_offset; | |
| 66 | |
| 67 static Handle basic_create(int length, bool tenured, TRAPS); | |
| 68 static Handle basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS); | |
| 69 | |
| 70 static void set_value( oop string, typeArrayOop buffer) { string->obj_field_put(value_offset, (oop)buffer); } | |
| 71 static void set_offset(oop string, int offset) { string->int_field_put(offset_offset, offset); } | |
| 72 static void set_count( oop string, int count) { string->int_field_put(count_offset, count); } | |
| 73 | |
| 74 public: | |
| 75 // Instance creation | |
| 76 static Handle create_from_unicode(jchar* unicode, int len, TRAPS); | |
| 77 static Handle create_tenured_from_unicode(jchar* unicode, int len, TRAPS); | |
| 78 static oop create_oop_from_unicode(jchar* unicode, int len, TRAPS); | |
| 79 static Handle create_from_str(const char* utf8_str, TRAPS); | |
| 80 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
|
81 static Handle create_from_symbol(Symbol* symbol, TRAPS); |
| 0 | 82 static Handle create_from_platform_dependent_str(const char* str, TRAPS); |
| 83 static Handle char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS); | |
| 84 | |
| 85 static int value_offset_in_bytes() { return value_offset; } | |
| 86 static int count_offset_in_bytes() { return count_offset; } | |
| 87 static int offset_offset_in_bytes() { return offset_offset; } | |
| 88 static int hash_offset_in_bytes() { return hash_offset; } | |
| 89 | |
| 90 // Accessors | |
| 91 static typeArrayOop value(oop java_string) { | |
| 92 assert(is_instance(java_string), "must be java_string"); | |
| 93 return (typeArrayOop) java_string->obj_field(value_offset); | |
| 94 } | |
| 95 static int offset(oop java_string) { | |
| 96 assert(is_instance(java_string), "must be java_string"); | |
| 97 return java_string->int_field(offset_offset); | |
| 98 } | |
| 99 static int length(oop java_string) { | |
| 100 assert(is_instance(java_string), "must be java_string"); | |
| 101 return java_string->int_field(count_offset); | |
| 102 } | |
| 103 static int utf8_length(oop java_string); | |
| 104 | |
| 105 // String converters | |
| 106 static char* as_utf8_string(oop java_string); | |
|
1989
017cd8bce8a8
6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents:
1972
diff
changeset
|
107 static char* as_utf8_string(oop java_string, char* buf, int buflen); |
| 0 | 108 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
|
109 static char* as_platform_dependent_str(Handle java_string, TRAPS); |
| 0 | 110 static jchar* as_unicode_string(oop java_string, int& length); |
| 111 | |
|
2418
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
112 // Compute the hash value for a java.lang.String object which would |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
113 // contain the characters passed in. This hash value is used for at |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
114 // least two purposes. |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
115 // |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
116 // (a) As the hash value used by the StringTable for bucket selection |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
117 // and comparison (stored in the HashtableEntry structures). This |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
118 // is used in the String.intern() method. |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
119 // |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
120 // (b) As the hash value used by the String object itself, in |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
121 // String.hashCode(). This value is normally calculate in Java code |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
122 // in the String.hashCode method(), but is precomputed for String |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
123 // objects in the shared archive file. |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
124 // |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
125 // For this reason, THIS ALGORITHM MUST MATCH String.hashCode(). |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
126 static unsigned int hash_string(jchar* s, int len) { |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
127 unsigned int h = 0; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
128 while (len-- > 0) { |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
129 h = 31*h + (unsigned int) *s; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
130 s++; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
131 } |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
132 return h; |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
133 } |
|
352622fd140a
7032129: Native memory usage grow unexpectedly for vm/oom/*InternedString tests
never
parents:
2376
diff
changeset
|
134 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
|
135 |
| 0 | 136 static bool equals(oop java_string, jchar* chars, int len); |
| 137 | |
| 138 // Conversion between '.' and '/' formats | |
| 139 static Handle externalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '/', '.', THREAD); } | |
| 140 static Handle internalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '.', '/', THREAD); } | |
| 141 | |
| 142 // Conversion | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
143 static Symbol* as_symbol(Handle java_string, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
144 static Symbol* as_symbol_or_null(oop java_string); |
| 0 | 145 |
| 146 // Testers | |
| 147 static bool is_instance(oop obj) { | |
| 1142 | 148 return obj != NULL && obj->klass() == SystemDictionary::String_klass(); |
| 0 | 149 } |
| 150 | |
| 151 // Debugging | |
| 152 static void print(Handle java_string, outputStream* st); | |
| 153 friend class JavaClasses; | |
| 154 }; | |
| 155 | |
| 156 | |
| 157 // Interface to java.lang.Class objects | |
| 158 | |
| 159 class java_lang_Class : AllStatic { | |
| 160 friend class VMStructs; | |
| 161 private: | |
| 162 // The fake offsets are added by the class loader when java.lang.Class is loaded | |
| 163 | |
| 164 enum { | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
165 hc_number_of_fake_oop_fields = 3, |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
166 hc_number_of_fake_int_fields = 2 |
| 0 | 167 }; |
| 168 | |
| 169 static int klass_offset; | |
| 170 static int resolved_constructor_offset; | |
| 171 static int array_klass_offset; | |
| 172 static int number_of_fake_oop_fields; | |
| 173 | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
174 static int oop_size_offset; |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
175 static int static_oop_field_count_offset; |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
176 |
| 0 | 177 static void compute_offsets(); |
| 178 static bool offsets_computed; | |
| 179 static int classRedefinedCount_offset; | |
| 514 | 180 static int parallelCapable_offset; |
| 0 | 181 |
| 182 public: | |
| 183 // Instance creation | |
| 184 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
|
185 static void fixup_mirror(KlassHandle k, TRAPS); |
| 0 | 186 static oop create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS); |
| 187 // Conversion | |
| 188 static klassOop as_klassOop(oop java_class); | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
189 static BasicType as_BasicType(oop java_class, klassOop* reference_klass = NULL); |
| 710 | 190 static BasicType as_BasicType(oop java_class, KlassHandle* reference_klass) { |
| 191 klassOop refk_oop = NULL; | |
| 192 BasicType result = as_BasicType(java_class, &refk_oop); | |
| 193 (*reference_klass) = KlassHandle(refk_oop); | |
| 194 return result; | |
| 195 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
196 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
|
197 static void print_signature(oop java_class, outputStream *st); |
| 0 | 198 // Testing |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
199 static bool is_instance(oop obj) { |
| 1142 | 200 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
|
201 } |
| 0 | 202 static bool is_primitive(oop java_class); |
| 203 static BasicType primitive_type(oop java_class); | |
| 204 static oop primitive_mirror(BasicType t); | |
| 205 // JVM_NewInstance support | |
| 206 static methodOop resolved_constructor(oop java_class); | |
| 207 static void set_resolved_constructor(oop java_class, methodOop constructor); | |
| 208 // JVM_NewArray support | |
| 209 static klassOop array_klass(oop java_class); | |
| 210 static void set_array_klass(oop java_class, klassOop klass); | |
| 211 // compiler support for class operations | |
| 212 static int klass_offset_in_bytes() { return klass_offset; } | |
| 213 static int resolved_constructor_offset_in_bytes() { return resolved_constructor_offset; } | |
| 214 static int array_klass_offset_in_bytes() { return array_klass_offset; } | |
| 215 // Support for classRedefinedCount field | |
| 216 static int classRedefinedCount(oop the_class_mirror); | |
| 217 static void set_classRedefinedCount(oop the_class_mirror, int value); | |
| 514 | 218 // Support for parallelCapable field |
| 219 static bool parallelCapable(oop the_class_mirror); | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
220 |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
221 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
|
222 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
|
223 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
|
224 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
|
225 |
| 0 | 226 // Debugging |
| 227 friend class JavaClasses; | |
| 228 friend class instanceKlass; // verification code accesses offsets | |
| 229 friend class ClassFileParser; // access to number_of_fake_fields | |
| 230 }; | |
| 231 | |
| 232 // Interface to java.lang.Thread objects | |
| 233 | |
| 234 class java_lang_Thread : AllStatic { | |
| 235 private: | |
| 236 // Note that for this class the layout changed between JDK1.2 and JDK1.3, | |
| 237 // so we compute the offsets at startup rather than hard-wiring them. | |
| 238 static int _name_offset; | |
| 239 static int _group_offset; | |
| 240 static int _contextClassLoader_offset; | |
| 241 static int _inheritedAccessControlContext_offset; | |
| 242 static int _priority_offset; | |
| 243 static int _eetop_offset; | |
| 244 static int _daemon_offset; | |
| 245 static int _stillborn_offset; | |
| 246 static int _stackSize_offset; | |
| 247 static int _tid_offset; | |
| 248 static int _thread_status_offset; | |
| 249 static int _park_blocker_offset; | |
| 250 static int _park_event_offset ; | |
| 251 | |
| 252 static void compute_offsets(); | |
| 253 | |
| 254 public: | |
| 255 // Instance creation | |
| 256 static oop create(); | |
| 257 // Returns the JavaThread associated with the thread obj | |
| 258 static JavaThread* thread(oop java_thread); | |
| 259 // Set JavaThread for instance | |
| 260 static void set_thread(oop java_thread, JavaThread* thread); | |
| 261 // Name | |
| 262 static typeArrayOop name(oop java_thread); | |
| 263 static void set_name(oop java_thread, typeArrayOop name); | |
| 264 // Priority | |
| 265 static ThreadPriority priority(oop java_thread); | |
| 266 static void set_priority(oop java_thread, ThreadPriority priority); | |
| 267 // Thread group | |
| 268 static oop threadGroup(oop java_thread); | |
| 269 // Stillborn | |
| 270 static bool is_stillborn(oop java_thread); | |
| 271 static void set_stillborn(oop java_thread); | |
| 272 // Alive (NOTE: this is not really a field, but provides the correct | |
| 273 // definition without doing a Java call) | |
| 274 static bool is_alive(oop java_thread); | |
| 275 // Daemon | |
| 276 static bool is_daemon(oop java_thread); | |
| 277 static void set_daemon(oop java_thread); | |
| 278 // Context ClassLoader | |
| 279 static oop context_class_loader(oop java_thread); | |
| 280 // Control context | |
| 281 static oop inherited_access_control_context(oop java_thread); | |
| 282 // Stack size hint | |
| 283 static jlong stackSize(oop java_thread); | |
| 284 // Thread ID | |
| 285 static jlong thread_id(oop java_thread); | |
| 286 | |
| 287 // Blocker object responsible for thread parking | |
| 288 static oop park_blocker(oop java_thread); | |
| 289 | |
| 290 // Pointer to type-stable park handler, encoded as jlong. | |
| 291 // Should be set when apparently null | |
| 292 // For details, see unsafe.cpp Unsafe_Unpark | |
| 293 static jlong park_event(oop java_thread); | |
| 294 static bool set_park_event(oop java_thread, jlong ptr); | |
| 295 | |
| 296 // Java Thread Status for JVMTI and M&M use. | |
| 297 // This thread status info is saved in threadStatus field of | |
| 298 // java.lang.Thread java class. | |
| 299 enum ThreadStatus { | |
| 300 NEW = 0, | |
| 301 RUNNABLE = JVMTI_THREAD_STATE_ALIVE + // runnable / running | |
| 302 JVMTI_THREAD_STATE_RUNNABLE, | |
| 303 SLEEPING = JVMTI_THREAD_STATE_ALIVE + // Thread.sleep() | |
| 304 JVMTI_THREAD_STATE_WAITING + | |
| 305 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + | |
| 306 JVMTI_THREAD_STATE_SLEEPING, | |
| 307 IN_OBJECT_WAIT = JVMTI_THREAD_STATE_ALIVE + // Object.wait() | |
| 308 JVMTI_THREAD_STATE_WAITING + | |
| 309 JVMTI_THREAD_STATE_WAITING_INDEFINITELY + | |
| 310 JVMTI_THREAD_STATE_IN_OBJECT_WAIT, | |
| 311 IN_OBJECT_WAIT_TIMED = JVMTI_THREAD_STATE_ALIVE + // Object.wait(long) | |
| 312 JVMTI_THREAD_STATE_WAITING + | |
| 313 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + | |
| 314 JVMTI_THREAD_STATE_IN_OBJECT_WAIT, | |
| 315 PARKED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park() | |
| 316 JVMTI_THREAD_STATE_WAITING + | |
| 317 JVMTI_THREAD_STATE_WAITING_INDEFINITELY + | |
| 318 JVMTI_THREAD_STATE_PARKED, | |
| 319 PARKED_TIMED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park(long) | |
| 320 JVMTI_THREAD_STATE_WAITING + | |
| 321 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + | |
| 322 JVMTI_THREAD_STATE_PARKED, | |
| 323 BLOCKED_ON_MONITOR_ENTER = JVMTI_THREAD_STATE_ALIVE + // (re-)entering a synchronization block | |
| 324 JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER, | |
| 325 TERMINATED = JVMTI_THREAD_STATE_TERMINATED | |
| 326 }; | |
| 327 // Write thread status info to threadStatus field of java.lang.Thread. | |
| 328 static void set_thread_status(oop java_thread_oop, ThreadStatus status); | |
| 329 // Read thread status info from threadStatus field of java.lang.Thread. | |
| 330 static ThreadStatus get_thread_status(oop java_thread_oop); | |
| 331 | |
| 332 static const char* thread_status_name(oop java_thread_oop); | |
| 333 | |
| 334 // Debugging | |
| 335 friend class JavaClasses; | |
| 336 }; | |
| 337 | |
| 338 // Interface to java.lang.ThreadGroup objects | |
| 339 | |
| 340 class java_lang_ThreadGroup : AllStatic { | |
| 341 private: | |
| 342 static int _parent_offset; | |
| 343 static int _name_offset; | |
| 344 static int _threads_offset; | |
| 345 static int _groups_offset; | |
| 346 static int _maxPriority_offset; | |
| 347 static int _destroyed_offset; | |
| 348 static int _daemon_offset; | |
| 349 static int _vmAllowSuspension_offset; | |
| 350 static int _nthreads_offset; | |
| 351 static int _ngroups_offset; | |
| 352 | |
| 353 static void compute_offsets(); | |
| 354 | |
| 355 public: | |
| 356 // parent ThreadGroup | |
| 357 static oop parent(oop java_thread_group); | |
| 358 // name | |
| 359 static typeArrayOop name(oop java_thread_group); | |
| 360 // ("name as oop" accessor is not necessary) | |
| 361 // Number of threads in group | |
| 362 static int nthreads(oop java_thread_group); | |
| 363 // threads | |
| 364 static objArrayOop threads(oop java_thread_group); | |
| 365 // Number of threads in group | |
| 366 static int ngroups(oop java_thread_group); | |
| 367 // groups | |
| 368 static objArrayOop groups(oop java_thread_group); | |
| 369 // maxPriority in group | |
| 370 static ThreadPriority maxPriority(oop java_thread_group); | |
| 371 // Destroyed | |
| 372 static bool is_destroyed(oop java_thread_group); | |
| 373 // Daemon | |
| 374 static bool is_daemon(oop java_thread_group); | |
| 375 // vmAllowSuspension | |
| 376 static bool is_vmAllowSuspension(oop java_thread_group); | |
| 377 // Debugging | |
| 378 friend class JavaClasses; | |
| 379 }; | |
| 380 | |
| 381 | |
| 382 | |
| 383 // Interface to java.lang.Throwable objects | |
| 384 | |
| 385 class java_lang_Throwable: AllStatic { | |
| 386 friend class BacktraceBuilder; | |
| 387 | |
| 388 private: | |
| 389 // Offsets | |
| 390 enum { | |
| 391 hc_backtrace_offset = 0, | |
| 392 hc_detailMessage_offset = 1, | |
| 393 hc_cause_offset = 2, // New since 1.4 | |
| 394 hc_stackTrace_offset = 3 // New since 1.4 | |
| 395 }; | |
| 396 // Trace constants | |
| 397 enum { | |
| 398 trace_methods_offset = 0, | |
| 399 trace_bcis_offset = 1, | |
| 400 trace_next_offset = 2, | |
| 401 trace_size = 3, | |
| 402 trace_chunk_size = 32 | |
| 403 }; | |
| 404 | |
| 405 static int backtrace_offset; | |
| 406 static int detailMessage_offset; | |
| 407 static int cause_offset; | |
| 408 static int stackTrace_offset; | |
| 409 | |
| 410 // Printing | |
| 411 static char* print_stack_element_to_buffer(methodOop method, int bci); | |
| 412 static void print_to_stream(Handle stream, const char* str); | |
| 413 // StackTrace (programmatic access, new since 1.4) | |
| 414 static void clear_stacktrace(oop throwable); | |
| 415 // No stack trace available | |
| 416 static const char* no_stack_trace_message(); | |
| 417 | |
| 418 public: | |
| 419 // Backtrace | |
| 420 static oop backtrace(oop throwable); | |
| 421 static void set_backtrace(oop throwable, oop value); | |
| 422 // Needed by JVMTI to filter out this internal field. | |
| 423 static int get_backtrace_offset() { return backtrace_offset;} | |
| 424 static int get_detailMessage_offset() { return detailMessage_offset;} | |
| 425 // Message | |
| 426 static oop message(oop throwable); | |
| 427 static oop message(Handle throwable); | |
| 428 static void set_message(oop throwable, oop value); | |
| 429 // Print stack trace stored in exception by call-back to Java | |
| 430 // Note: this is no longer used in Merlin, but we still suppport | |
| 431 // it for compatibility. | |
| 432 static void print_stack_trace(oop throwable, oop print_stream); | |
| 433 static void print_stack_element(Handle stream, methodOop method, int bci); | |
| 434 static void print_stack_element(outputStream *st, methodOop method, int bci); | |
| 435 static void print_stack_usage(Handle stream); | |
| 436 | |
| 437 // Allocate space for backtrace (created but stack trace not filled in) | |
| 438 static void allocate_backtrace(Handle throwable, TRAPS); | |
| 439 // Fill in current stack trace for throwable with preallocated backtrace (no GC) | |
| 440 static void fill_in_stack_trace_of_preallocated_backtrace(Handle throwable); | |
| 441 | |
| 442 // Fill in current stack trace, can cause GC | |
| 443 static void fill_in_stack_trace(Handle throwable, TRAPS); | |
| 444 static void fill_in_stack_trace(Handle throwable); | |
| 445 // Programmatic access to stack trace | |
| 446 static oop get_stack_trace_element(oop throwable, int index, TRAPS); | |
| 447 static int get_stack_trace_depth(oop throwable, TRAPS); | |
| 448 // Printing | |
| 449 static void print(oop throwable, outputStream* st); | |
| 450 static void print(Handle throwable, outputStream* st); | |
| 451 static void print_stack_trace(oop throwable, outputStream* st); | |
| 452 // Debugging | |
| 453 friend class JavaClasses; | |
| 454 }; | |
| 455 | |
| 456 | |
| 457 // Interface to java.lang.reflect.AccessibleObject objects | |
| 458 | |
| 459 class java_lang_reflect_AccessibleObject: AllStatic { | |
| 460 private: | |
| 461 // Note that to reduce dependencies on the JDK we compute these | |
| 462 // offsets at run-time. | |
| 463 static int override_offset; | |
| 464 | |
| 465 static void compute_offsets(); | |
| 466 | |
| 467 public: | |
| 468 // Accessors | |
| 469 static jboolean override(oop reflect); | |
| 470 static void set_override(oop reflect, jboolean value); | |
| 471 | |
| 472 // Debugging | |
| 473 friend class JavaClasses; | |
| 474 }; | |
| 475 | |
| 476 | |
| 477 // Interface to java.lang.reflect.Method objects | |
| 478 | |
| 479 class java_lang_reflect_Method : public java_lang_reflect_AccessibleObject { | |
| 480 private: | |
| 481 // Note that to reduce dependencies on the JDK we compute these | |
| 482 // offsets at run-time. | |
| 483 static int clazz_offset; | |
| 484 static int name_offset; | |
| 485 static int returnType_offset; | |
| 486 static int parameterTypes_offset; | |
| 487 static int exceptionTypes_offset; | |
| 488 static int slot_offset; | |
| 489 static int modifiers_offset; | |
| 490 static int signature_offset; | |
| 491 static int annotations_offset; | |
| 492 static int parameter_annotations_offset; | |
| 493 static int annotation_default_offset; | |
| 494 | |
| 495 static void compute_offsets(); | |
| 496 | |
| 497 public: | |
| 498 // Allocation | |
| 499 static Handle create(TRAPS); | |
| 500 | |
| 501 // Accessors | |
| 502 static oop clazz(oop reflect); | |
| 503 static void set_clazz(oop reflect, oop value); | |
| 504 | |
| 505 static oop name(oop method); | |
| 506 static void set_name(oop method, oop value); | |
| 507 | |
| 508 static oop return_type(oop method); | |
| 509 static void set_return_type(oop method, oop value); | |
| 510 | |
| 511 static oop parameter_types(oop method); | |
| 512 static void set_parameter_types(oop method, oop value); | |
| 513 | |
| 514 static oop exception_types(oop method); | |
| 515 static void set_exception_types(oop method, oop value); | |
| 516 | |
| 517 static int slot(oop reflect); | |
| 518 static void set_slot(oop reflect, int value); | |
| 519 | |
| 520 static int modifiers(oop method); | |
| 521 static void set_modifiers(oop method, int value); | |
| 522 | |
| 523 static bool has_signature_field(); | |
| 524 static oop signature(oop method); | |
| 525 static void set_signature(oop method, oop value); | |
| 526 | |
| 527 static bool has_annotations_field(); | |
| 528 static oop annotations(oop method); | |
| 529 static void set_annotations(oop method, oop value); | |
| 530 | |
| 531 static bool has_parameter_annotations_field(); | |
| 532 static oop parameter_annotations(oop method); | |
| 533 static void set_parameter_annotations(oop method, oop value); | |
| 534 | |
| 535 static bool has_annotation_default_field(); | |
| 536 static oop annotation_default(oop method); | |
| 537 static void set_annotation_default(oop method, oop value); | |
| 538 | |
| 539 // Debugging | |
| 540 friend class JavaClasses; | |
| 541 }; | |
| 542 | |
| 543 | |
| 544 // Interface to java.lang.reflect.Constructor objects | |
| 545 | |
| 546 class java_lang_reflect_Constructor : public java_lang_reflect_AccessibleObject { | |
| 547 private: | |
| 548 // Note that to reduce dependencies on the JDK we compute these | |
| 549 // offsets at run-time. | |
| 550 static int clazz_offset; | |
| 551 static int parameterTypes_offset; | |
| 552 static int exceptionTypes_offset; | |
| 553 static int slot_offset; | |
| 554 static int modifiers_offset; | |
| 555 static int signature_offset; | |
| 556 static int annotations_offset; | |
| 557 static int parameter_annotations_offset; | |
| 558 | |
| 559 static void compute_offsets(); | |
| 560 | |
| 561 public: | |
| 562 // Allocation | |
| 563 static Handle create(TRAPS); | |
| 564 | |
| 565 // Accessors | |
| 566 static oop clazz(oop reflect); | |
| 567 static void set_clazz(oop reflect, oop value); | |
| 568 | |
| 569 static oop parameter_types(oop constructor); | |
| 570 static void set_parameter_types(oop constructor, oop value); | |
| 571 | |
| 572 static oop exception_types(oop constructor); | |
| 573 static void set_exception_types(oop constructor, oop value); | |
| 574 | |
| 575 static int slot(oop reflect); | |
| 576 static void set_slot(oop reflect, int value); | |
| 577 | |
| 578 static int modifiers(oop constructor); | |
| 579 static void set_modifiers(oop constructor, int value); | |
| 580 | |
| 581 static bool has_signature_field(); | |
| 582 static oop signature(oop constructor); | |
| 583 static void set_signature(oop constructor, oop value); | |
| 584 | |
| 585 static bool has_annotations_field(); | |
| 586 static oop annotations(oop constructor); | |
| 587 static void set_annotations(oop constructor, oop value); | |
| 588 | |
| 589 static bool has_parameter_annotations_field(); | |
| 590 static oop parameter_annotations(oop method); | |
| 591 static void set_parameter_annotations(oop method, oop value); | |
| 592 | |
| 593 // Debugging | |
| 594 friend class JavaClasses; | |
| 595 }; | |
| 596 | |
| 597 | |
| 598 // Interface to java.lang.reflect.Field objects | |
| 599 | |
| 600 class java_lang_reflect_Field : public java_lang_reflect_AccessibleObject { | |
| 601 private: | |
| 602 // Note that to reduce dependencies on the JDK we compute these | |
| 603 // offsets at run-time. | |
| 604 static int clazz_offset; | |
| 605 static int name_offset; | |
| 606 static int type_offset; | |
| 607 static int slot_offset; | |
| 608 static int modifiers_offset; | |
| 609 static int signature_offset; | |
| 610 static int annotations_offset; | |
| 611 | |
| 612 static void compute_offsets(); | |
| 613 | |
| 614 public: | |
| 615 // Allocation | |
| 616 static Handle create(TRAPS); | |
| 617 | |
| 618 // Accessors | |
| 619 static oop clazz(oop reflect); | |
| 620 static void set_clazz(oop reflect, oop value); | |
| 621 | |
| 622 static oop name(oop field); | |
| 623 static void set_name(oop field, oop value); | |
| 624 | |
| 625 static oop type(oop field); | |
| 626 static void set_type(oop field, oop value); | |
| 627 | |
| 628 static int slot(oop reflect); | |
| 629 static void set_slot(oop reflect, int value); | |
| 630 | |
| 631 static int modifiers(oop field); | |
| 632 static void set_modifiers(oop field, int value); | |
| 633 | |
| 634 static bool has_signature_field(); | |
| 635 static oop signature(oop constructor); | |
| 636 static void set_signature(oop constructor, oop value); | |
| 637 | |
| 638 static bool has_annotations_field(); | |
| 639 static oop annotations(oop constructor); | |
| 640 static void set_annotations(oop constructor, oop value); | |
| 641 | |
| 642 static bool has_parameter_annotations_field(); | |
| 643 static oop parameter_annotations(oop method); | |
| 644 static void set_parameter_annotations(oop method, oop value); | |
| 645 | |
| 646 static bool has_annotation_default_field(); | |
| 647 static oop annotation_default(oop method); | |
| 648 static void set_annotation_default(oop method, oop value); | |
| 649 | |
| 650 // Debugging | |
| 651 friend class JavaClasses; | |
| 652 }; | |
| 653 | |
| 654 // Interface to sun.reflect.ConstantPool objects | |
| 655 class sun_reflect_ConstantPool { | |
| 656 private: | |
| 657 // Note that to reduce dependencies on the JDK we compute these | |
| 658 // offsets at run-time. | |
| 659 static int _cp_oop_offset; | |
| 660 | |
| 661 static void compute_offsets(); | |
| 662 | |
| 663 public: | |
| 664 // Allocation | |
| 665 static Handle create(TRAPS); | |
| 666 | |
| 667 // Accessors | |
| 668 static oop cp_oop(oop reflect); | |
| 669 static void set_cp_oop(oop reflect, oop value); | |
| 670 static int cp_oop_offset() { | |
| 671 return _cp_oop_offset; | |
| 672 } | |
| 673 | |
| 674 // Debugging | |
| 675 friend class JavaClasses; | |
| 676 }; | |
| 677 | |
| 678 // Interface to sun.reflect.UnsafeStaticFieldAccessorImpl objects | |
| 679 class sun_reflect_UnsafeStaticFieldAccessorImpl { | |
| 680 private: | |
| 681 static int _base_offset; | |
| 682 static void compute_offsets(); | |
| 683 | |
| 684 public: | |
| 685 static int base_offset() { | |
| 686 return _base_offset; | |
| 687 } | |
| 688 | |
| 689 // Debugging | |
| 690 friend class JavaClasses; | |
| 691 }; | |
| 692 | |
| 693 // Interface to java.lang primitive type boxing objects: | |
| 694 // - java.lang.Boolean | |
| 695 // - java.lang.Character | |
| 696 // - java.lang.Float | |
| 697 // - java.lang.Double | |
| 698 // - java.lang.Byte | |
| 699 // - java.lang.Short | |
| 700 // - java.lang.Integer | |
| 701 // - java.lang.Long | |
| 702 | |
| 703 // This could be separated out into 8 individual classes. | |
| 704 | |
| 705 class java_lang_boxing_object: AllStatic { | |
| 706 private: | |
| 707 enum { | |
| 708 hc_value_offset = 0 | |
| 709 }; | |
| 710 static int value_offset; | |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
711 static int long_value_offset; |
| 0 | 712 |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
713 static oop initialize_and_allocate(BasicType type, TRAPS); |
| 0 | 714 public: |
| 715 // Allocation. Returns a boxed value, or NULL for invalid type. | |
| 716 static oop create(BasicType type, jvalue* value, TRAPS); | |
| 717 // Accessors. Returns the basic type being boxed, or T_ILLEGAL for invalid oop. | |
| 718 static BasicType get_value(oop box, jvalue* value); | |
| 719 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
|
720 static BasicType basic_type(oop box); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
113
diff
changeset
|
721 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
|
722 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
|
723 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
|
724 static void print(BasicType type, jvalue* value, outputStream* st); |
| 0 | 725 |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
726 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
|
727 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
|
728 value_offset; |
|
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
132
diff
changeset
|
729 } |
| 0 | 730 |
| 731 // Debugging | |
| 732 friend class JavaClasses; | |
| 733 }; | |
| 734 | |
| 735 | |
| 736 | |
| 737 // Interface to java.lang.ref.Reference objects | |
| 738 | |
| 739 class java_lang_ref_Reference: AllStatic { | |
| 740 public: | |
| 741 enum { | |
| 742 hc_referent_offset = 0, | |
| 743 hc_queue_offset = 1, | |
| 744 hc_next_offset = 2, | |
| 745 hc_discovered_offset = 3 // Is not last, see SoftRefs. | |
| 746 }; | |
| 747 enum { | |
| 748 hc_static_lock_offset = 0, | |
| 749 hc_static_pending_offset = 1 | |
| 750 }; | |
| 751 | |
| 752 static int referent_offset; | |
| 753 static int queue_offset; | |
| 754 static int next_offset; | |
| 755 static int discovered_offset; | |
| 756 static int static_lock_offset; | |
| 757 static int static_pending_offset; | |
| 758 static int number_of_fake_oop_fields; | |
| 759 | |
| 760 // Accessors | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
761 static oop referent(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
762 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
|
763 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
764 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
|
765 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
|
766 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
767 static void set_referent_raw(oop ref, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
768 ref->obj_field_raw_put(referent_offset, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
769 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
770 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
|
771 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
|
772 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
773 static oop next(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
774 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
|
775 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
776 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
|
777 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
|
778 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
779 static void set_next_raw(oop ref, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
780 ref->obj_field_raw_put(next_offset, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
781 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
782 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
|
783 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
|
784 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
785 static oop discovered(oop ref) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
786 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
|
787 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
788 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
|
789 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
|
790 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
791 static void set_discovered_raw(oop ref, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
792 ref->obj_field_raw_put(discovered_offset, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
793 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
794 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
|
795 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
|
796 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
797 // Accessors for statics |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
798 static oop pending_list_lock(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
799 static oop pending_list(); |
| 0 | 800 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
22
diff
changeset
|
801 static HeapWord* pending_list_addr(); |
| 0 | 802 }; |
| 803 | |
| 804 | |
| 805 // Interface to java.lang.ref.SoftReference objects | |
| 806 | |
| 807 class java_lang_ref_SoftReference: public java_lang_ref_Reference { | |
| 808 public: | |
| 809 enum { | |
| 810 // 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
|
811 hc_timestamp_offset = hc_discovered_offset + 1 |
| 0 | 812 }; |
| 813 enum { | |
| 814 hc_static_clock_offset = 0 | |
| 815 }; | |
| 816 | |
| 817 static int timestamp_offset; | |
| 818 static int static_clock_offset; | |
| 819 | |
| 820 // Accessors | |
| 821 static jlong timestamp(oop ref); | |
| 822 | |
| 823 // Accessors for statics | |
| 824 static jlong clock(); | |
| 825 static void set_clock(jlong value); | |
| 826 }; | |
| 827 | |
| 828 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
829 // Interface to java.lang.invoke.MethodHandle objects |
| 710 | 830 |
| 831 class MethodHandleEntry; | |
| 832 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
833 class java_lang_invoke_MethodHandle: AllStatic { |
| 710 | 834 friend class JavaClasses; |
| 835 | |
| 836 private: | |
| 837 static int _vmentry_offset; // assembly code trampoline for MH | |
| 838 static int _vmtarget_offset; // class-specific target reference | |
| 839 static int _type_offset; // the MethodType of this MH | |
| 840 static int _vmslots_offset; // OPTIONAL hoisted type.form.vmslots | |
| 841 | |
| 842 static void compute_offsets(); | |
| 843 | |
| 844 public: | |
| 845 // Accessors | |
| 846 static oop type(oop mh); | |
| 847 static void set_type(oop mh, oop mtype); | |
| 848 | |
| 849 static oop vmtarget(oop mh); | |
| 850 static void set_vmtarget(oop mh, oop target); | |
| 851 | |
| 852 static MethodHandleEntry* vmentry(oop mh); | |
| 853 static void set_vmentry(oop mh, MethodHandleEntry* data); | |
| 854 | |
| 855 static int vmslots(oop mh); | |
| 856 static void init_vmslots(oop mh); | |
| 857 static int compute_vmslots(oop mh); | |
| 858 | |
| 859 // Testers | |
| 860 static bool is_subclass(klassOop klass) { | |
| 861 return Klass::cast(klass)->is_subclass_of(SystemDictionary::MethodHandle_klass()); | |
| 862 } | |
| 863 static bool is_instance(oop obj) { | |
| 864 return obj != NULL && is_subclass(obj->klass()); | |
| 865 } | |
| 866 | |
| 867 // Accessors for code generation: | |
| 868 static int type_offset_in_bytes() { return _type_offset; } | |
| 869 static int vmtarget_offset_in_bytes() { return _vmtarget_offset; } | |
| 870 static int vmentry_offset_in_bytes() { return _vmentry_offset; } | |
| 871 static int vmslots_offset_in_bytes() { return _vmslots_offset; } | |
| 872 }; | |
| 873 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
874 class java_lang_invoke_DirectMethodHandle: public java_lang_invoke_MethodHandle { |
| 710 | 875 friend class JavaClasses; |
| 876 | |
| 877 private: | |
| 878 // _vmtarget_offset; // method or class or interface | |
| 879 static int _vmindex_offset; // negative or vtable idx or itable idx | |
| 880 static void compute_offsets(); | |
| 881 | |
| 882 public: | |
| 883 // Accessors | |
| 884 static int vmindex(oop mh); | |
| 885 static void set_vmindex(oop mh, int index); | |
| 886 | |
| 887 // Testers | |
| 888 static bool is_subclass(klassOop klass) { | |
| 889 return Klass::cast(klass)->is_subclass_of(SystemDictionary::DirectMethodHandle_klass()); | |
| 890 } | |
| 891 static bool is_instance(oop obj) { | |
| 892 return obj != NULL && is_subclass(obj->klass()); | |
| 893 } | |
| 894 | |
| 895 // Accessors for code generation: | |
| 896 static int vmindex_offset_in_bytes() { return _vmindex_offset; } | |
| 897 }; | |
| 898 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
899 class java_lang_invoke_BoundMethodHandle: public java_lang_invoke_MethodHandle { |
| 710 | 900 friend class JavaClasses; |
| 901 | |
| 902 private: | |
| 903 static int _argument_offset; // argument value bound into this MH | |
| 904 static int _vmargslot_offset; // relevant argument slot (<= vmslots) | |
| 905 static void compute_offsets(); | |
| 906 | |
| 907 public: | |
| 908 static oop argument(oop mh); | |
| 909 static void set_argument(oop mh, oop ref); | |
| 910 | |
| 911 static jint vmargslot(oop mh); | |
| 912 static void set_vmargslot(oop mh, jint slot); | |
| 913 | |
| 914 // Testers | |
| 915 static bool is_subclass(klassOop klass) { | |
| 916 return Klass::cast(klass)->is_subclass_of(SystemDictionary::BoundMethodHandle_klass()); | |
| 917 } | |
| 918 static bool is_instance(oop obj) { | |
| 919 return obj != NULL && is_subclass(obj->klass()); | |
| 920 } | |
| 921 | |
| 922 static int argument_offset_in_bytes() { return _argument_offset; } | |
| 923 static int vmargslot_offset_in_bytes() { return _vmargslot_offset; } | |
| 924 }; | |
| 925 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
926 class java_lang_invoke_AdapterMethodHandle: public java_lang_invoke_BoundMethodHandle { |
| 710 | 927 friend class JavaClasses; |
| 928 | |
| 929 private: | |
| 930 static int _conversion_offset; // type of conversion to apply | |
| 931 static void compute_offsets(); | |
| 932 | |
| 933 public: | |
| 934 static int conversion(oop mh); | |
| 935 static void set_conversion(oop mh, int conv); | |
| 936 | |
| 937 // Testers | |
| 938 static bool is_subclass(klassOop klass) { | |
| 939 return Klass::cast(klass)->is_subclass_of(SystemDictionary::AdapterMethodHandle_klass()); | |
| 940 } | |
| 941 static bool is_instance(oop obj) { | |
| 942 return obj != NULL && is_subclass(obj->klass()); | |
| 943 } | |
| 944 | |
| 945 // Relevant integer codes (keep these in synch. with MethodHandleNatives.Constants): | |
| 946 enum { | |
| 947 OP_RETYPE_ONLY = 0x0, // no argument changes; straight retype | |
|
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
948 OP_RETYPE_RAW = 0x1, // straight retype, trusted (void->int, Object->T) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
949 OP_CHECK_CAST = 0x2, // ref-to-ref conversion; requires a Class argument |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
950 OP_PRIM_TO_PRIM = 0x3, // converts from one primitive to another |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
951 OP_REF_TO_PRIM = 0x4, // unboxes a wrapper to produce a primitive |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
952 OP_PRIM_TO_REF = 0x5, // boxes a primitive into a wrapper (NYI) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
953 OP_SWAP_ARGS = 0x6, // swap arguments (vminfo is 2nd arg) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
954 OP_ROT_ARGS = 0x7, // rotate arguments (vminfo is displaced arg) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
955 OP_DUP_ARGS = 0x8, // duplicates one or more arguments (at TOS) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
956 OP_DROP_ARGS = 0x9, // remove one or more argument slots |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
957 OP_COLLECT_ARGS = 0xA, // combine one or more arguments into a varargs (NYI) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
958 OP_SPREAD_ARGS = 0xB, // expand in place a varargs array (of known size) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
959 OP_FLYBY = 0xC, // operate first on reified argument list (NYI) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
960 OP_RICOCHET = 0xD, // run an adapter chain on the return value (NYI) |
|
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
961 CONV_OP_LIMIT = 0xE, // limit of CONV_OP enumeration |
| 710 | 962 |
| 963 CONV_OP_MASK = 0xF00, // this nybble contains the conversion op field | |
| 964 CONV_VMINFO_MASK = 0x0FF, // LSB is reserved for JVM use | |
| 965 CONV_VMINFO_SHIFT = 0, // position of bits in CONV_VMINFO_MASK | |
| 966 CONV_OP_SHIFT = 8, // position of bits in CONV_OP_MASK | |
| 967 CONV_DEST_TYPE_SHIFT = 12, // byte 2 has the adapter BasicType (if needed) | |
| 968 CONV_SRC_TYPE_SHIFT = 16, // byte 2 has the source BasicType (if needed) | |
| 969 CONV_STACK_MOVE_SHIFT = 20, // high 12 bits give signed SP change | |
| 970 CONV_STACK_MOVE_MASK = (1 << (32 - CONV_STACK_MOVE_SHIFT)) - 1 | |
| 971 }; | |
| 972 | |
| 973 static int conversion_offset_in_bytes() { return _conversion_offset; } | |
| 974 }; | |
| 975 | |
| 976 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
977 // Interface to java.lang.invoke.MemberName objects |
| 710 | 978 // (These are a private interface for Java code to query the class hierarchy.) |
| 979 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
980 class java_lang_invoke_MemberName: AllStatic { |
| 710 | 981 friend class JavaClasses; |
| 982 | |
| 983 private: | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
984 // From java.lang.invoke.MemberName: |
| 710 | 985 // private Class<?> clazz; // class in which the method is defined |
| 986 // private String name; // may be null if not yet materialized | |
| 987 // private Object type; // may be null if not yet materialized | |
| 988 // private int flags; // modifier bits; see reflect.Modifier | |
| 989 // private Object vmtarget; // VM-specific target value | |
| 990 // private int vmindex; // method index within class or interface | |
| 991 static int _clazz_offset; | |
| 992 static int _name_offset; | |
| 993 static int _type_offset; | |
| 994 static int _flags_offset; | |
| 995 static int _vmtarget_offset; | |
| 996 static int _vmindex_offset; | |
| 997 | |
| 998 static void compute_offsets(); | |
| 999 | |
| 1000 public: | |
| 1001 // Accessors | |
| 1002 static oop clazz(oop mname); | |
| 1003 static void set_clazz(oop mname, oop clazz); | |
| 1004 | |
| 1005 static oop type(oop mname); | |
| 1006 static void set_type(oop mname, oop type); | |
| 1007 | |
| 1008 static oop name(oop mname); | |
| 1009 static void set_name(oop mname, oop name); | |
| 1010 | |
| 1011 static int flags(oop mname); | |
| 1012 static void set_flags(oop mname, int flags); | |
| 1013 | |
| 1014 static int modifiers(oop mname) { return (u2) flags(mname); } | |
| 1015 static void set_modifiers(oop mname, int mods) | |
| 1016 { set_flags(mname, (flags(mname) &~ (u2)-1) | (u2)mods); } | |
| 1017 | |
| 1018 static oop vmtarget(oop mname); | |
| 1019 static void set_vmtarget(oop mname, oop target); | |
| 1020 | |
| 1021 static int vmindex(oop mname); | |
| 1022 static void set_vmindex(oop mname, int index); | |
| 1023 | |
| 1024 // Testers | |
| 1025 static bool is_subclass(klassOop klass) { | |
| 1026 return Klass::cast(klass)->is_subclass_of(SystemDictionary::MemberName_klass()); | |
| 1027 } | |
| 1028 static bool is_instance(oop obj) { | |
| 1029 return obj != NULL && is_subclass(obj->klass()); | |
| 1030 } | |
| 1031 | |
| 1032 // Relevant integer codes (keep these in synch. with MethodHandleNatives.Constants): | |
| 1033 enum { | |
| 1034 MN_IS_METHOD = 0x00010000, // method (not constructor) | |
| 1035 MN_IS_CONSTRUCTOR = 0x00020000, // constructor | |
| 1036 MN_IS_FIELD = 0x00040000, // field | |
| 1037 MN_IS_TYPE = 0x00080000, // nested type | |
| 1038 MN_SEARCH_SUPERCLASSES = 0x00100000, // for MHN.getMembers | |
| 1039 MN_SEARCH_INTERFACES = 0x00200000, // for MHN.getMembers | |
| 1040 VM_INDEX_UNINITIALIZED = -99 | |
| 1041 }; | |
| 1042 | |
| 1043 // Accessors for code generation: | |
| 1044 static int clazz_offset_in_bytes() { return _clazz_offset; } | |
| 1045 static int type_offset_in_bytes() { return _type_offset; } | |
| 1046 static int name_offset_in_bytes() { return _name_offset; } | |
| 1047 static int flags_offset_in_bytes() { return _flags_offset; } | |
| 1048 static int vmtarget_offset_in_bytes() { return _vmtarget_offset; } | |
| 1049 static int vmindex_offset_in_bytes() { return _vmindex_offset; } | |
| 1050 }; | |
| 1051 | |
| 1052 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1053 // Interface to java.lang.invoke.MethodType objects |
| 710 | 1054 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1055 class java_lang_invoke_MethodType: AllStatic { |
| 710 | 1056 friend class JavaClasses; |
| 1057 | |
| 1058 private: | |
| 1059 static int _rtype_offset; | |
| 1060 static int _ptypes_offset; | |
| 1061 static int _form_offset; | |
| 1062 | |
| 1063 static void compute_offsets(); | |
| 1064 | |
| 1065 public: | |
| 1066 // Accessors | |
| 1067 static oop rtype(oop mt); | |
| 1068 static objArrayOop ptypes(oop mt); | |
| 1069 static oop form(oop mt); | |
| 1070 | |
| 1071 static oop ptype(oop mt, int index); | |
|
1133
aa62b9388fce
6894206: JVM needs a way to traverse method handle structures
twisti
parents:
1059
diff
changeset
|
1072 static int ptype_count(oop mt); |
| 710 | 1073 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1989
diff
changeset
|
1074 static Symbol* as_signature(oop mt, bool intern_if_not_found, TRAPS); |
| 710 | 1075 static void print_signature(oop mt, outputStream* st); |
| 1076 | |
| 1077 static bool is_instance(oop obj) { | |
| 1078 return obj != NULL && obj->klass() == SystemDictionary::MethodType_klass(); | |
| 1079 } | |
| 1080 | |
| 1081 // Accessors for code generation: | |
| 1082 static int rtype_offset_in_bytes() { return _rtype_offset; } | |
| 1083 static int ptypes_offset_in_bytes() { return _ptypes_offset; } | |
| 1084 static int form_offset_in_bytes() { return _form_offset; } | |
| 1085 }; | |
| 1086 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1087 class java_lang_invoke_MethodTypeForm: AllStatic { |
| 710 | 1088 friend class JavaClasses; |
| 1089 | |
| 1090 private: | |
| 1091 static int _vmslots_offset; // number of argument slots needed | |
| 1092 static int _erasedType_offset; // erasedType = canonical MethodType | |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1552
diff
changeset
|
1093 static int _genericInvoker_offset; // genericInvoker = adapter for invokeGeneric |
| 710 | 1094 |
| 1095 static void compute_offsets(); | |
| 1096 | |
| 1097 public: | |
| 1098 // Accessors | |
| 1099 static int vmslots(oop mtform); | |
| 1100 static oop erasedType(oop mtform); | |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1552
diff
changeset
|
1101 static oop genericInvoker(oop mtform); |
| 710 | 1102 |
| 1103 // Accessors for code generation: | |
| 1104 static int vmslots_offset_in_bytes() { return _vmslots_offset; } | |
| 1105 static int erasedType_offset_in_bytes() { return _erasedType_offset; } | |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1552
diff
changeset
|
1106 static int genericInvoker_offset_in_bytes() { return _genericInvoker_offset; } |
| 710 | 1107 }; |
| 1108 | |
| 1109 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1110 // Interface to java.lang.invoke.CallSite objects |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1111 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
1112 class java_lang_invoke_CallSite: AllStatic { |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1113 friend class JavaClasses; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1114 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1115 private: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1116 static int _target_offset; |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1117 static int _caller_method_offset; |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1118 static int _caller_bci_offset; |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1119 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1120 static void compute_offsets(); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1121 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1122 public: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1123 // Accessors |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1124 static oop target(oop site); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1125 static void set_target(oop site, oop target); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1126 |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1127 static oop caller_method(oop site); |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1128 static void set_caller_method(oop site, oop ref); |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1129 |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1130 static jint caller_bci(oop site); |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1131 static void set_caller_bci(oop site, jint bci); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1132 |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1133 // Testers |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1134 static bool is_subclass(klassOop klass) { |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1135 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
|
1136 } |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1137 static bool is_instance(oop obj) { |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1138 return obj != NULL && is_subclass(obj->klass()); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1139 } |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1133
diff
changeset
|
1140 |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1141 // Accessors for code generation: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1142 static int target_offset_in_bytes() { return _target_offset; } |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1143 static int caller_method_offset_in_bytes() { return _caller_method_offset; } |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1144 static int caller_bci_offset_in_bytes() { return _caller_bci_offset; } |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1145 }; |
| 710 | 1146 |
| 1147 | |
| 0 | 1148 // Interface to java.security.AccessControlContext objects |
| 1149 | |
| 1150 class java_security_AccessControlContext: AllStatic { | |
| 1151 private: | |
| 1152 // Note that for this class the layout changed between JDK1.2 and JDK1.3, | |
| 1153 // so we compute the offsets at startup rather than hard-wiring them. | |
| 1154 static int _context_offset; | |
| 1155 static int _privilegedContext_offset; | |
| 1156 static int _isPrivileged_offset; | |
| 1157 | |
| 1158 static void compute_offsets(); | |
| 1159 public: | |
| 1160 static oop create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS); | |
| 1161 | |
| 1162 // Debugging/initialization | |
| 1163 friend class JavaClasses; | |
| 1164 }; | |
| 1165 | |
| 1166 | |
| 1167 // Interface to java.lang.ClassLoader objects | |
| 1168 | |
| 1169 class java_lang_ClassLoader : AllStatic { | |
| 1170 private: | |
| 1171 enum { | |
| 1172 hc_parent_offset = 0 | |
| 1173 }; | |
| 1174 | |
| 1175 static int parent_offset; | |
| 1176 | |
| 1177 public: | |
| 1178 static oop parent(oop loader); | |
| 1179 | |
| 1180 static bool is_trusted_loader(oop loader); | |
| 1181 | |
| 1182 // Fix for 4474172 | |
| 1183 static oop non_reflection_class_loader(oop loader); | |
| 1184 | |
| 1185 // Debugging | |
| 1186 friend class JavaClasses; | |
| 1187 }; | |
| 1188 | |
| 1189 | |
| 1190 // Interface to java.lang.System objects | |
| 1191 | |
| 1192 class java_lang_System : AllStatic { | |
| 1193 private: | |
| 1194 enum { | |
| 1195 hc_static_in_offset = 0, | |
| 1196 hc_static_out_offset = 1, | |
| 1197 hc_static_err_offset = 2 | |
| 1198 }; | |
| 1199 | |
| 1200 static int static_in_offset; | |
| 1201 static int static_out_offset; | |
| 1202 static int static_err_offset; | |
| 1203 | |
| 1204 public: | |
| 1205 static int in_offset_in_bytes(); | |
| 1206 static int out_offset_in_bytes(); | |
| 1207 static int err_offset_in_bytes(); | |
| 1208 | |
| 1209 // Debugging | |
| 1210 friend class JavaClasses; | |
| 1211 }; | |
| 1212 | |
| 1213 | |
| 1214 // Interface to java.lang.StackTraceElement objects | |
| 1215 | |
| 1216 class java_lang_StackTraceElement: AllStatic { | |
| 1217 private: | |
| 1218 enum { | |
| 1219 hc_declaringClass_offset = 0, | |
| 1220 hc_methodName_offset = 1, | |
| 1221 hc_fileName_offset = 2, | |
| 1222 hc_lineNumber_offset = 3 | |
| 1223 }; | |
| 1224 | |
| 1225 static int declaringClass_offset; | |
| 1226 static int methodName_offset; | |
| 1227 static int fileName_offset; | |
| 1228 static int lineNumber_offset; | |
| 1229 | |
| 1230 public: | |
| 1231 // Setters | |
| 1232 static void set_declaringClass(oop element, oop value); | |
| 1233 static void set_methodName(oop element, oop value); | |
| 1234 static void set_fileName(oop element, oop value); | |
| 1235 static void set_lineNumber(oop element, int value); | |
| 1236 | |
| 1237 // Create an instance of StackTraceElement | |
| 1238 static oop create(methodHandle m, int bci, TRAPS); | |
| 1239 | |
| 1240 // Debugging | |
| 1241 friend class JavaClasses; | |
| 1242 }; | |
| 1243 | |
| 1244 | |
| 1245 // Interface to java.lang.AssertionStatusDirectives objects | |
| 1246 | |
| 1247 class java_lang_AssertionStatusDirectives: AllStatic { | |
| 1248 private: | |
| 1249 enum { | |
| 1250 hc_classes_offset, | |
| 1251 hc_classEnabled_offset, | |
| 1252 hc_packages_offset, | |
| 1253 hc_packageEnabled_offset, | |
| 1254 hc_deflt_offset | |
| 1255 }; | |
| 1256 | |
| 1257 static int classes_offset; | |
| 1258 static int classEnabled_offset; | |
| 1259 static int packages_offset; | |
| 1260 static int packageEnabled_offset; | |
| 1261 static int deflt_offset; | |
| 1262 | |
| 1263 public: | |
| 1264 // Setters | |
| 1265 static void set_classes(oop obj, oop val); | |
| 1266 static void set_classEnabled(oop obj, oop val); | |
| 1267 static void set_packages(oop obj, oop val); | |
| 1268 static void set_packageEnabled(oop obj, oop val); | |
| 1269 static void set_deflt(oop obj, bool val); | |
| 1270 // Debugging | |
| 1271 friend class JavaClasses; | |
| 1272 }; | |
| 1273 | |
| 1274 | |
| 1275 class java_nio_Buffer: AllStatic { | |
| 1276 private: | |
| 1277 static int _limit_offset; | |
| 1278 | |
| 1279 public: | |
| 1280 static int limit_offset(); | |
| 1281 static void compute_offsets(); | |
| 1282 }; | |
| 1283 | |
| 1284 class sun_misc_AtomicLongCSImpl: AllStatic { | |
| 1285 private: | |
| 1286 static int _value_offset; | |
| 1287 | |
| 1288 public: | |
| 1289 static int value_offset(); | |
| 1290 static void compute_offsets(); | |
| 1291 }; | |
| 1292 | |
| 1293 class java_util_concurrent_locks_AbstractOwnableSynchronizer : AllStatic { | |
| 1294 private: | |
| 1295 static int _owner_offset; | |
| 1296 public: | |
| 1297 static void initialize(TRAPS); | |
| 1298 static oop get_owner_threadObj(oop obj); | |
| 1299 }; | |
| 1300 | |
| 1301 // Interface to hard-coded offset checking | |
| 1302 | |
| 1303 class JavaClasses : AllStatic { | |
| 1304 private: | |
| 1305 static bool check_offset(const char *klass_name, int offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0; | |
| 1306 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
|
1307 static bool check_constant(const char *klass_name, int constant, const char *field_name, const char* field_sig) PRODUCT_RETURN0; |
| 0 | 1308 public: |
| 1309 static void compute_hard_coded_offsets(); | |
| 1310 static void compute_offsets(); | |
| 1311 static void check_offsets() PRODUCT_RETURN; | |
| 1312 }; | |
| 1972 | 1313 |
| 1314 #endif // SHARE_VM_CLASSFILE_JAVACLASSES_HPP |