Mon, 12 Nov 2012 14:03:53 -0800
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
1 /*
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_CLASSFILE_JAVACLASSES_HPP
26 #define SHARE_VM_CLASSFILE_JAVACLASSES_HPP
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"
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.
51 // Interface to java.lang.String objects
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;
60 static bool initialized;
62 static Handle basic_create(int length, TRAPS);
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 }
81 public:
82 static void compute_offsets();
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);
89 static Handle create_from_symbol(Symbol* symbol, TRAPS);
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);
93 static bool has_offset_field() {
94 assert(initialized, "Must be initialized");
95 return (offset_offset > 0);
96 }
98 static bool has_count_field() {
99 assert(initialized, "Must be initialized");
100 return (count_offset > 0);
101 }
103 static bool has_hash_field() {
104 assert(initialized, "Must be initialized");
105 return (hash_offset > 0);
106 }
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 }
125 // Accessors
126 static typeArrayOop value(oop java_string) {
127 assert(initialized && (value_offset > 0), "Must be initialized");
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) {
132 assert(initialized, "Must be initialized");
133 assert(is_instance(java_string), "must be java_string");
134 if (offset_offset > 0) {
135 return java_string->int_field(offset_offset);
136 } else {
137 return 0;
138 }
139 }
140 static int length(oop java_string) {
141 assert(initialized, "Must be initialized");
142 assert(is_instance(java_string), "must be java_string");
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 }
148 }
149 static int utf8_length(oop java_string);
151 // String converters
152 static char* as_utf8_string(oop java_string);
153 static char* as_utf8_string(oop java_string, char* buf, int buflen);
154 static char* as_utf8_string(oop java_string, int start, int len);
155 static char* as_platform_dependent_str(Handle java_string, TRAPS);
156 static jchar* as_unicode_string(oop java_string, int& length);
157 // produce an ascii string with all other values quoted using \u####
158 static char* as_quoted_ascii(oop java_string);
160 // Compute the hash value for a java.lang.String object which would
161 // contain the characters passed in.
162 //
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
168 //
169 // For this reason, THIS ALGORITHM MUST MATCH String.toHash().
170 template <typename T> static unsigned int to_hash(T* s, int len) {
171 unsigned int h = 0;
172 while (len-- > 0) {
173 h = 31*h + (unsigned int) *s;
174 s++;
175 }
176 return h;
177 }
178 static unsigned int to_hash(oop java_string);
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.
182 static unsigned int hash_string(oop java_string);
184 static bool equals(oop java_string, jchar* chars, int len);
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); }
190 // Conversion
191 static Symbol* as_symbol(Handle java_string, TRAPS);
192 static Symbol* as_symbol_or_null(oop java_string);
194 // Testers
195 static bool is_instance(oop obj) {
196 return obj != NULL && obj->klass() == SystemDictionary::String_klass();
197 }
199 // Debugging
200 static void print(Handle java_string, outputStream* st);
201 friend class JavaClasses;
202 };
205 // Interface to java.lang.Class objects
207 #define CLASS_INJECTED_FIELDS(macro) \
208 macro(java_lang_Class, klass, intptr_signature, false) \
209 macro(java_lang_Class, resolved_constructor, intptr_signature, false) \
210 macro(java_lang_Class, array_klass, intptr_signature, false) \
211 macro(java_lang_Class, oop_size, int_signature, false) \
212 macro(java_lang_Class, static_oop_field_count, int_signature, false)
214 class java_lang_Class : AllStatic {
215 friend class VMStructs;
217 private:
218 // The fake offsets are added by the class loader when java.lang.Class is loaded
220 static int _klass_offset;
221 static int _resolved_constructor_offset;
222 static int _array_klass_offset;
224 static int _oop_size_offset;
225 static int _static_oop_field_count_offset;
227 static bool offsets_computed;
228 static int classRedefinedCount_offset;
229 static GrowableArray<Klass*>* _fixup_mirror_list;
231 public:
232 static void compute_offsets();
234 // Instance creation
235 static oop create_mirror(KlassHandle k, TRAPS);
236 static void fixup_mirror(KlassHandle k, TRAPS);
237 static oop create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS);
238 // Conversion
239 static Klass* as_Klass(oop java_class);
240 static void set_klass(oop java_class, Klass* klass);
241 static BasicType as_BasicType(oop java_class, Klass** reference_klass = NULL);
242 static BasicType as_BasicType(oop java_class, KlassHandle* reference_klass) {
243 Klass* refk_oop = NULL;
244 BasicType result = as_BasicType(java_class, &refk_oop);
245 (*reference_klass) = KlassHandle(refk_oop);
246 return result;
247 }
248 static Symbol* as_signature(oop java_class, bool intern_if_not_found, TRAPS);
249 static void print_signature(oop java_class, outputStream *st);
250 // Testing
251 static bool is_instance(oop obj) {
252 return obj != NULL && obj->klass() == SystemDictionary::Class_klass();
253 }
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
258 static Method* resolved_constructor(oop java_class);
259 static void set_resolved_constructor(oop java_class, Method* constructor);
260 // JVM_NewArray support
261 static Klass* array_klass(oop java_class);
262 static void set_array_klass(oop java_class, Klass* klass);
263 // compiler support for class operations
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; }
267 // Support for classRedefinedCount field
268 static int classRedefinedCount(oop the_class_mirror);
269 static void set_classRedefinedCount(oop the_class_mirror, int value);
271 static int oop_size(oop java_class);
272 static void set_oop_size(oop java_class, int size);
273 static int static_oop_field_count(oop java_class);
274 static void set_static_oop_field_count(oop java_class, int size);
276 static GrowableArray<Klass*>* fixup_mirror_list() {
277 return _fixup_mirror_list;
278 }
279 static void set_fixup_mirror_list(GrowableArray<Klass*>* v) {
280 _fixup_mirror_list = v;
281 }
282 // Debugging
283 friend class JavaClasses;
284 friend class InstanceKlass; // verification code accesses offsets
285 friend class ClassFileParser; // access to number_of_fake_fields
286 };
288 // Interface to java.lang.Thread objects
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 ;
308 static void compute_offsets();
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);
343 // Blocker object responsible for thread parking
344 static oop park_blocker(oop java_thread);
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);
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);
388 static const char* thread_status_name(oop java_thread_oop);
390 // Debugging
391 friend class JavaClasses;
392 };
394 // Interface to java.lang.ThreadGroup objects
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;
409 static void compute_offsets();
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 };
439 // Interface to java.lang.Throwable objects
441 class java_lang_Throwable: AllStatic {
442 friend class BacktraceBuilder;
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 };
452 enum {
453 hc_static_unassigned_stacktrace_offset = 0 // New since 1.7
454 };
455 // Trace constants
456 enum {
457 trace_methods_offset = 0,
458 trace_bcis_offset = 1,
459 trace_mirrors_offset = 2,
460 trace_next_offset = 3,
461 trace_size = 4,
462 trace_chunk_size = 32
463 };
465 static int backtrace_offset;
466 static int detailMessage_offset;
467 static int cause_offset;
468 static int stackTrace_offset;
469 static int static_unassigned_stacktrace_offset;
471 // Printing
472 static char* print_stack_element_to_buffer(Method* method, int bci);
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();
478 // Stacktrace (post JDK 1.7.0 to allow immutability protocol to be followed)
479 static void set_stacktrace(oop throwable, oop st_element_array);
480 static oop unassigned_stacktrace();
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);
497 static void print_stack_element(Handle stream, Method* method, int bci);
498 static void print_stack_element(outputStream *st, Method* method, int bci);
499 static void print_stack_usage(Handle stream);
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
506 static void fill_in_stack_trace(Handle throwable, methodHandle method, TRAPS);
507 static void fill_in_stack_trace(Handle throwable, methodHandle method = methodHandle());
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 };
520 // Interface to java.lang.reflect.AccessibleObject objects
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;
528 static void compute_offsets();
530 public:
531 // Accessors
532 static jboolean override(oop reflect);
533 static void set_override(oop reflect, jboolean value);
535 // Debugging
536 friend class JavaClasses;
537 };
540 // Interface to java.lang.reflect.Method objects
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;
558 static void compute_offsets();
560 public:
561 // Allocation
562 static Handle create(TRAPS);
564 // Accessors
565 static oop clazz(oop reflect);
566 static void set_clazz(oop reflect, oop value);
568 static oop name(oop method);
569 static void set_name(oop method, oop value);
571 static oop return_type(oop method);
572 static void set_return_type(oop method, oop value);
574 static oop parameter_types(oop method);
575 static void set_parameter_types(oop method, oop value);
577 static oop exception_types(oop method);
578 static void set_exception_types(oop method, oop value);
580 static int slot(oop reflect);
581 static void set_slot(oop reflect, int value);
583 static int modifiers(oop method);
584 static void set_modifiers(oop method, int value);
586 static bool has_signature_field();
587 static oop signature(oop method);
588 static void set_signature(oop method, oop value);
590 static bool has_annotations_field();
591 static oop annotations(oop method);
592 static void set_annotations(oop method, oop value);
594 static bool has_parameter_annotations_field();
595 static oop parameter_annotations(oop method);
596 static void set_parameter_annotations(oop method, oop value);
598 static bool has_annotation_default_field();
599 static oop annotation_default(oop method);
600 static void set_annotation_default(oop method, oop value);
602 // Debugging
603 friend class JavaClasses;
604 };
607 // Interface to java.lang.reflect.Constructor objects
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;
622 static void compute_offsets();
624 public:
625 // Allocation
626 static Handle create(TRAPS);
628 // Accessors
629 static oop clazz(oop reflect);
630 static void set_clazz(oop reflect, oop value);
632 static oop parameter_types(oop constructor);
633 static void set_parameter_types(oop constructor, oop value);
635 static oop exception_types(oop constructor);
636 static void set_exception_types(oop constructor, oop value);
638 static int slot(oop reflect);
639 static void set_slot(oop reflect, int value);
641 static int modifiers(oop constructor);
642 static void set_modifiers(oop constructor, int value);
644 static bool has_signature_field();
645 static oop signature(oop constructor);
646 static void set_signature(oop constructor, oop value);
648 static bool has_annotations_field();
649 static oop annotations(oop constructor);
650 static void set_annotations(oop constructor, oop value);
652 static bool has_parameter_annotations_field();
653 static oop parameter_annotations(oop method);
654 static void set_parameter_annotations(oop method, oop value);
656 // Debugging
657 friend class JavaClasses;
658 };
661 // Interface to java.lang.reflect.Field objects
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;
675 static void compute_offsets();
677 public:
678 // Allocation
679 static Handle create(TRAPS);
681 // Accessors
682 static oop clazz(oop reflect);
683 static void set_clazz(oop reflect, oop value);
685 static oop name(oop field);
686 static void set_name(oop field, oop value);
688 static oop type(oop field);
689 static void set_type(oop field, oop value);
691 static int slot(oop reflect);
692 static void set_slot(oop reflect, int value);
694 static int modifiers(oop field);
695 static void set_modifiers(oop field, int value);
697 static bool has_signature_field();
698 static oop signature(oop constructor);
699 static void set_signature(oop constructor, oop value);
701 static bool has_annotations_field();
702 static oop annotations(oop constructor);
703 static void set_annotations(oop constructor, oop value);
705 static bool has_parameter_annotations_field();
706 static oop parameter_annotations(oop method);
707 static void set_parameter_annotations(oop method, oop value);
709 static bool has_annotation_default_field();
710 static oop annotation_default(oop method);
711 static void set_annotation_default(oop method, oop value);
713 // Debugging
714 friend class JavaClasses;
715 };
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.
722 static int _oop_offset;
724 static void compute_offsets();
726 public:
727 // Allocation
728 static Handle create(TRAPS);
730 // Accessors
731 static void set_cp(oop reflect, ConstantPool* value);
732 static int oop_offset() {
733 return _oop_offset;
734 }
736 static ConstantPool* get_cp(oop reflect);
738 // Debugging
739 friend class JavaClasses;
740 };
742 // Interface to sun.reflect.UnsafeStaticFieldAccessorImpl objects
743 class sun_reflect_UnsafeStaticFieldAccessorImpl {
744 private:
745 static int _base_offset;
746 static void compute_offsets();
748 public:
749 static int base_offset() {
750 return _base_offset;
751 }
753 // Debugging
754 friend class JavaClasses;
755 };
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
767 // This could be separated out into 8 individual classes.
769 class java_lang_boxing_object: AllStatic {
770 private:
771 enum {
772 hc_value_offset = 0
773 };
774 static int value_offset;
775 static int long_value_offset;
777 static oop initialize_and_allocate(BasicType type, TRAPS);
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);
784 static BasicType basic_type(oop box);
785 static bool is_instance(oop box) { return basic_type(box) != T_ILLEGAL; }
786 static bool is_instance(oop box, BasicType type) { return basic_type(box) == type; }
787 static void print(oop box, outputStream* st) { jvalue value; print(get_value(box, &value), &value, st); }
788 static void print(BasicType type, jvalue* value, outputStream* st);
790 static int value_offset_in_bytes(BasicType type) {
791 return ( type == T_LONG || type == T_DOUBLE ) ? long_value_offset :
792 value_offset;
793 }
795 // Debugging
796 friend class JavaClasses;
797 };
801 // Interface to java.lang.ref.Reference objects
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 };
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;
824 // Accessors
825 static oop referent(oop ref) {
826 return ref->obj_field(referent_offset);
827 }
828 static void set_referent(oop ref, oop value) {
829 ref->obj_field_put(referent_offset, value);
830 }
831 static void set_referent_raw(oop ref, oop value) {
832 ref->obj_field_put_raw(referent_offset, value);
833 }
834 static HeapWord* referent_addr(oop ref) {
835 return ref->obj_field_addr<HeapWord>(referent_offset);
836 }
837 static oop next(oop ref) {
838 return ref->obj_field(next_offset);
839 }
840 static void set_next(oop ref, oop value) {
841 ref->obj_field_put(next_offset, value);
842 }
843 static void set_next_raw(oop ref, oop value) {
844 ref->obj_field_put_raw(next_offset, value);
845 }
846 static HeapWord* next_addr(oop ref) {
847 return ref->obj_field_addr<HeapWord>(next_offset);
848 }
849 static oop discovered(oop ref) {
850 return ref->obj_field(discovered_offset);
851 }
852 static void set_discovered(oop ref, oop value) {
853 ref->obj_field_put(discovered_offset, value);
854 }
855 static void set_discovered_raw(oop ref, oop value) {
856 ref->obj_field_put_raw(discovered_offset, value);
857 }
858 static HeapWord* discovered_addr(oop ref) {
859 return ref->obj_field_addr<HeapWord>(discovered_offset);
860 }
861 // Accessors for statics
862 static oop pending_list_lock();
863 static oop pending_list();
865 static HeapWord* pending_list_lock_addr();
866 static HeapWord* pending_list_addr();
867 };
870 // Interface to java.lang.ref.SoftReference objects
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.
876 hc_timestamp_offset = hc_discovered_offset + 1
877 };
878 enum {
879 hc_static_clock_offset = 0
880 };
882 static int timestamp_offset;
883 static int static_clock_offset;
885 // Accessors
886 static jlong timestamp(oop ref);
888 // Accessors for statics
889 static jlong clock();
890 static void set_clock(jlong value);
891 };
894 // Interface to java.lang.invoke.MethodHandle objects
896 class MethodHandleEntry;
898 class java_lang_invoke_MethodHandle: AllStatic {
899 friend class JavaClasses;
901 private:
902 static int _type_offset; // the MethodType of this MH
903 static int _form_offset; // the LambdaForm of this MH
905 static void compute_offsets();
907 public:
908 // Accessors
909 static oop type(oop mh);
910 static void set_type(oop mh, oop mtype);
912 static oop form(oop mh);
913 static void set_form(oop mh, oop lform);
915 // Testers
916 static bool is_subclass(Klass* klass) {
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 }
923 // Accessors for code generation:
924 static int type_offset_in_bytes() { return _type_offset; }
925 static int form_offset_in_bytes() { return _form_offset; }
926 };
928 // Interface to java.lang.invoke.LambdaForm objects
929 // (These are a private interface for managing adapter code generation.)
931 class java_lang_invoke_LambdaForm: AllStatic {
932 friend class JavaClasses;
934 private:
935 static int _vmentry_offset; // type is MemberName
937 static void compute_offsets();
939 public:
940 // Accessors
941 static oop vmentry(oop lform);
942 static void set_vmentry(oop lform, oop invoker);
944 // Testers
945 static bool is_subclass(Klass* klass) {
946 return SystemDictionary::LambdaForm_klass() != NULL &&
947 Klass::cast(klass)->is_subclass_of(SystemDictionary::LambdaForm_klass());
948 }
949 static bool is_instance(oop obj) {
950 return obj != NULL && is_subclass(obj->klass());
951 }
953 // Accessors for code generation:
954 static int vmentry_offset_in_bytes() { return _vmentry_offset; }
955 };
958 // Interface to java.lang.invoke.MemberName objects
959 // (These are a private interface for Java code to query the class hierarchy.)
961 #define MEMBERNAME_INJECTED_FIELDS(macro) \
962 macro(java_lang_invoke_MemberName, vmloader, object_signature, false) \
963 macro(java_lang_invoke_MemberName, vmindex, intptr_signature, false) \
964 macro(java_lang_invoke_MemberName, vmtarget, intptr_signature, false)
966 class java_lang_invoke_MemberName: AllStatic {
967 friend class JavaClasses;
969 private:
970 // From java.lang.invoke.MemberName:
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
975 // private intptr vmtarget; // VM-specific target value
976 // private intptr_t vmindex; // member index within class or interface
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;
982 static int _vmloader_offset;
983 static int _vmindex_offset;
985 static void compute_offsets();
987 public:
988 // Accessors
989 static oop clazz(oop mname);
990 static void set_clazz(oop mname, oop clazz);
992 static oop type(oop mname);
993 static void set_type(oop mname, oop type);
995 static oop name(oop mname);
996 static void set_name(oop mname, oop name);
998 static int flags(oop mname);
999 static void set_flags(oop mname, int flags);
1001 static Metadata* vmtarget(oop mname);
1002 static void set_vmtarget(oop mname, Metadata* target);
1004 static intptr_t vmindex(oop mname);
1005 static void set_vmindex(oop mname, intptr_t index);
1007 // Testers
1008 static bool is_subclass(Klass* klass) {
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 }
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
1021 MN_REFERENCE_KIND_SHIFT = 24, // refKind
1022 MN_REFERENCE_KIND_MASK = 0x0F000000 >> MN_REFERENCE_KIND_SHIFT,
1023 // The SEARCH_* bits are not for MN.flags but for the matchFlags argument of MHN.getMembers:
1024 MN_SEARCH_SUPERCLASSES = 0x00100000, // walk super classes
1025 MN_SEARCH_INTERFACES = 0x00200000 // walk implemented interfaces
1026 };
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 };
1038 // Interface to java.lang.invoke.MethodType objects
1040 class java_lang_invoke_MethodType: AllStatic {
1041 friend class JavaClasses;
1043 private:
1044 static int _rtype_offset;
1045 static int _ptypes_offset;
1047 static void compute_offsets();
1049 public:
1050 // Accessors
1051 static oop rtype(oop mt);
1052 static objArrayOop ptypes(oop mt);
1054 static oop ptype(oop mt, int index);
1055 static int ptype_count(oop mt);
1057 static int ptype_slot_count(oop mt); // extra counts for long/double
1058 static int rtype_slot_count(oop mt); // extra counts for long/double
1060 static Symbol* as_signature(oop mt, bool intern_if_not_found, TRAPS);
1061 static void print_signature(oop mt, outputStream* st);
1063 static bool is_instance(oop obj) {
1064 return obj != NULL && obj->klass() == SystemDictionary::MethodType_klass();
1065 }
1067 static bool equals(oop mt1, oop mt2);
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 };
1075 // Interface to java.lang.invoke.CallSite objects
1077 class java_lang_invoke_CallSite: AllStatic {
1078 friend class JavaClasses;
1080 private:
1081 static int _target_offset;
1083 static void compute_offsets();
1085 public:
1086 // Accessors
1087 static oop target( oop site) { return site->obj_field( _target_offset); }
1088 static void set_target( oop site, oop target) { site->obj_field_put( _target_offset, target); }
1090 static volatile oop target_volatile(oop site) { return site->obj_field_volatile( _target_offset); }
1091 static void set_target_volatile(oop site, oop target) { site->obj_field_put_volatile(_target_offset, target); }
1093 // Testers
1094 static bool is_subclass(Klass* klass) {
1095 return Klass::cast(klass)->is_subclass_of(SystemDictionary::CallSite_klass());
1096 }
1097 static bool is_instance(oop obj) {
1098 return obj != NULL && is_subclass(obj->klass());
1099 }
1101 // Accessors for code generation:
1102 static int target_offset_in_bytes() { return _target_offset; }
1103 };
1106 // Interface to java.security.AccessControlContext objects
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;
1116 static void compute_offsets();
1117 public:
1118 static oop create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS);
1120 // Debugging/initialization
1121 friend class JavaClasses;
1122 };
1125 // Interface to java.lang.ClassLoader objects
1127 #define CLASSLOADER_INJECTED_FIELDS(macro) \
1128 macro(java_lang_ClassLoader, loader_data, intptr_signature, false) \
1129 macro(java_lang_ClassLoader, dependencies, object_signature, false)
1131 class java_lang_ClassLoader : AllStatic {
1132 private:
1133 // The fake offsets are added by the class loader when java.lang.Class is loaded
1134 enum {
1135 hc_parent_offset = 0
1136 };
1137 static int _loader_data_offset;
1138 static int _dependencies_offset;
1139 static bool offsets_computed;
1140 static int parent_offset;
1141 static int parallelCapable_offset;
1143 public:
1144 static void compute_offsets();
1146 static ClassLoaderData** loader_data_addr(oop loader);
1147 static ClassLoaderData* loader_data(oop loader);
1149 static oop dependencies(oop loader);
1150 static HeapWord* dependencies_addr(oop loader);
1152 static oop parent(oop loader);
1153 static bool isAncestor(oop loader, oop cl);
1155 // Support for parallelCapable field
1156 static bool parallelCapable(oop the_class_mirror);
1158 static bool is_trusted_loader(oop loader);
1160 // Fix for 4474172
1161 static oop non_reflection_class_loader(oop loader);
1163 // Testers
1164 static bool is_subclass(Klass* klass) {
1165 return Klass::cast(klass)->is_subclass_of(SystemDictionary::ClassLoader_klass());
1166 }
1167 static bool is_instance(oop obj) {
1168 return obj != NULL && is_subclass(obj->klass());
1169 }
1171 // Debugging
1172 friend class JavaClasses;
1173 friend class ClassFileParser; // access to number_of_fake_fields
1174 };
1177 // Interface to java.lang.System objects
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 };
1187 static int static_in_offset;
1188 static int static_out_offset;
1189 static int static_err_offset;
1191 public:
1192 static int in_offset_in_bytes();
1193 static int out_offset_in_bytes();
1194 static int err_offset_in_bytes();
1196 // Debugging
1197 friend class JavaClasses;
1198 };
1201 // Interface to java.lang.StackTraceElement objects
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 };
1212 static int declaringClass_offset;
1213 static int methodName_offset;
1214 static int fileName_offset;
1215 static int lineNumber_offset;
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);
1224 // Create an instance of StackTraceElement
1225 static oop create(methodHandle m, int bci, TRAPS);
1227 // Debugging
1228 friend class JavaClasses;
1229 };
1232 // Interface to java.lang.AssertionStatusDirectives objects
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 };
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;
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 };
1262 class java_nio_Buffer: AllStatic {
1263 private:
1264 static int _limit_offset;
1266 public:
1267 static int limit_offset();
1268 static void compute_offsets();
1269 };
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 };
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.
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;
1296 Klass* klass() const { return SystemDictionary::well_known_klass(klass_id); }
1297 Symbol* name() const { return lookup_symbol(name_index); }
1298 Symbol* signature() const { return lookup_symbol(signature_index); }
1300 int compute_offset();
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 };
1308 #define DECLARE_INJECTED_FIELD_ENUM(klass, name, signature, may_be_java) \
1309 klass##_##name##_enum,
1311 #define ALL_INJECTED_FIELDS(macro) \
1312 CLASS_INJECTED_FIELDS(macro) \
1313 CLASSLOADER_INJECTED_FIELDS(macro) \
1314 MEMBERNAME_INJECTED_FIELDS(macro)
1316 // Interface to hard-coded offset checking
1318 class JavaClasses : AllStatic {
1319 private:
1321 static InjectedField _injected_fields[];
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;
1325 static bool check_constant(const char *klass_name, int constant, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
1327 public:
1328 enum InjectedFieldID {
1329 ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD_ENUM)
1330 MAX_enum
1331 };
1333 static int compute_injected_offset(InjectedFieldID id);
1335 static void compute_hard_coded_offsets();
1336 static void compute_offsets();
1337 static void check_offsets() PRODUCT_RETURN;
1339 static InjectedField* get_injected(Symbol* class_name, int* field_count);
1340 };
1342 #undef DECLARE_INJECTED_FIELD_ENUM
1344 #endif // SHARE_VM_CLASSFILE_JAVACLASSES_HPP