Tue, 14 May 2013 11:34:30 +0400
8014448: Purge PrintCompactFieldsSavings
Summary: Remove obsolete debugging code.
Reviewed-by: dholmes, kvn
Contributed-by: Aleksey Shipilev <aleksey.shipilev@oracle.com>
1 /*
2 * Copyright (c) 1997, 2013, 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, TRAPS);
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.hashCode().
170 template <typename T> static unsigned int hash_code(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 hash_code(oop java_string);
180 // This is the string hash code used by the StringTable, which may be
181 // the same as String.hashCode 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, array_klass, intptr_signature, false) \
210 macro(java_lang_Class, oop_size, int_signature, false) \
211 macro(java_lang_Class, static_oop_field_count, int_signature, false)
213 class java_lang_Class : AllStatic {
214 friend class VMStructs;
216 private:
217 // The fake offsets are added by the class loader when java.lang.Class is loaded
219 static int _klass_offset;
220 static int _array_klass_offset;
222 static int _oop_size_offset;
223 static int _static_oop_field_count_offset;
225 static bool offsets_computed;
226 static int classRedefinedCount_offset;
227 static GrowableArray<Klass*>* _fixup_mirror_list;
229 public:
230 static void compute_offsets();
232 // Instance creation
233 static oop create_mirror(KlassHandle k, TRAPS);
234 static void fixup_mirror(KlassHandle k, TRAPS);
235 static oop create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS);
236 // Conversion
237 static Klass* as_Klass(oop java_class);
238 static void set_klass(oop java_class, Klass* klass);
239 static BasicType as_BasicType(oop java_class, Klass** reference_klass = NULL);
240 static BasicType as_BasicType(oop java_class, KlassHandle* reference_klass) {
241 Klass* refk_oop = NULL;
242 BasicType result = as_BasicType(java_class, &refk_oop);
243 (*reference_klass) = KlassHandle(refk_oop);
244 return result;
245 }
246 static Symbol* as_signature(oop java_class, bool intern_if_not_found, TRAPS);
247 static void print_signature(oop java_class, outputStream *st);
248 // Testing
249 static bool is_instance(oop obj) {
250 return obj != NULL && obj->klass() == SystemDictionary::Class_klass();
251 }
252 static bool is_primitive(oop java_class);
253 static BasicType primitive_type(oop java_class);
254 static oop primitive_mirror(BasicType t);
255 // JVM_NewArray support
256 static Klass* array_klass(oop java_class);
257 static void set_array_klass(oop java_class, Klass* klass);
258 // compiler support for class operations
259 static int klass_offset_in_bytes() { return _klass_offset; }
260 static int array_klass_offset_in_bytes() { return _array_klass_offset; }
261 // Support for classRedefinedCount field
262 static int classRedefinedCount(oop the_class_mirror);
263 static void set_classRedefinedCount(oop the_class_mirror, int value);
265 static int oop_size(oop java_class);
266 static void set_oop_size(oop java_class, int size);
267 static int static_oop_field_count(oop java_class);
268 static void set_static_oop_field_count(oop java_class, int size);
270 static GrowableArray<Klass*>* fixup_mirror_list() {
271 return _fixup_mirror_list;
272 }
273 static void set_fixup_mirror_list(GrowableArray<Klass*>* v) {
274 _fixup_mirror_list = v;
275 }
276 // Debugging
277 friend class JavaClasses;
278 friend class InstanceKlass; // verification code accesses offsets
279 friend class ClassFileParser; // access to number_of_fake_fields
280 };
282 // Interface to java.lang.Thread objects
284 class java_lang_Thread : AllStatic {
285 private:
286 // Note that for this class the layout changed between JDK1.2 and JDK1.3,
287 // so we compute the offsets at startup rather than hard-wiring them.
288 static int _name_offset;
289 static int _group_offset;
290 static int _contextClassLoader_offset;
291 static int _inheritedAccessControlContext_offset;
292 static int _priority_offset;
293 static int _eetop_offset;
294 static int _daemon_offset;
295 static int _stillborn_offset;
296 static int _stackSize_offset;
297 static int _tid_offset;
298 static int _thread_status_offset;
299 static int _park_blocker_offset;
300 static int _park_event_offset ;
302 static void compute_offsets();
304 public:
305 // Instance creation
306 static oop create();
307 // Returns the JavaThread associated with the thread obj
308 static JavaThread* thread(oop java_thread);
309 // Set JavaThread for instance
310 static void set_thread(oop java_thread, JavaThread* thread);
311 // Name
312 static typeArrayOop name(oop java_thread);
313 static void set_name(oop java_thread, typeArrayOop name);
314 // Priority
315 static ThreadPriority priority(oop java_thread);
316 static void set_priority(oop java_thread, ThreadPriority priority);
317 // Thread group
318 static oop threadGroup(oop java_thread);
319 // Stillborn
320 static bool is_stillborn(oop java_thread);
321 static void set_stillborn(oop java_thread);
322 // Alive (NOTE: this is not really a field, but provides the correct
323 // definition without doing a Java call)
324 static bool is_alive(oop java_thread);
325 // Daemon
326 static bool is_daemon(oop java_thread);
327 static void set_daemon(oop java_thread);
328 // Context ClassLoader
329 static oop context_class_loader(oop java_thread);
330 // Control context
331 static oop inherited_access_control_context(oop java_thread);
332 // Stack size hint
333 static jlong stackSize(oop java_thread);
334 // Thread ID
335 static jlong thread_id(oop java_thread);
337 // Blocker object responsible for thread parking
338 static oop park_blocker(oop java_thread);
340 // Pointer to type-stable park handler, encoded as jlong.
341 // Should be set when apparently null
342 // For details, see unsafe.cpp Unsafe_Unpark
343 static jlong park_event(oop java_thread);
344 static bool set_park_event(oop java_thread, jlong ptr);
346 // Java Thread Status for JVMTI and M&M use.
347 // This thread status info is saved in threadStatus field of
348 // java.lang.Thread java class.
349 enum ThreadStatus {
350 NEW = 0,
351 RUNNABLE = JVMTI_THREAD_STATE_ALIVE + // runnable / running
352 JVMTI_THREAD_STATE_RUNNABLE,
353 SLEEPING = JVMTI_THREAD_STATE_ALIVE + // Thread.sleep()
354 JVMTI_THREAD_STATE_WAITING +
355 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
356 JVMTI_THREAD_STATE_SLEEPING,
357 IN_OBJECT_WAIT = JVMTI_THREAD_STATE_ALIVE + // Object.wait()
358 JVMTI_THREAD_STATE_WAITING +
359 JVMTI_THREAD_STATE_WAITING_INDEFINITELY +
360 JVMTI_THREAD_STATE_IN_OBJECT_WAIT,
361 IN_OBJECT_WAIT_TIMED = JVMTI_THREAD_STATE_ALIVE + // Object.wait(long)
362 JVMTI_THREAD_STATE_WAITING +
363 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
364 JVMTI_THREAD_STATE_IN_OBJECT_WAIT,
365 PARKED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park()
366 JVMTI_THREAD_STATE_WAITING +
367 JVMTI_THREAD_STATE_WAITING_INDEFINITELY +
368 JVMTI_THREAD_STATE_PARKED,
369 PARKED_TIMED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park(long)
370 JVMTI_THREAD_STATE_WAITING +
371 JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
372 JVMTI_THREAD_STATE_PARKED,
373 BLOCKED_ON_MONITOR_ENTER = JVMTI_THREAD_STATE_ALIVE + // (re-)entering a synchronization block
374 JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER,
375 TERMINATED = JVMTI_THREAD_STATE_TERMINATED
376 };
377 // Write thread status info to threadStatus field of java.lang.Thread.
378 static void set_thread_status(oop java_thread_oop, ThreadStatus status);
379 // Read thread status info from threadStatus field of java.lang.Thread.
380 static ThreadStatus get_thread_status(oop java_thread_oop);
382 static const char* thread_status_name(oop java_thread_oop);
384 // Debugging
385 friend class JavaClasses;
386 };
388 // Interface to java.lang.ThreadGroup objects
390 class java_lang_ThreadGroup : AllStatic {
391 private:
392 static int _parent_offset;
393 static int _name_offset;
394 static int _threads_offset;
395 static int _groups_offset;
396 static int _maxPriority_offset;
397 static int _destroyed_offset;
398 static int _daemon_offset;
399 static int _vmAllowSuspension_offset;
400 static int _nthreads_offset;
401 static int _ngroups_offset;
403 static void compute_offsets();
405 public:
406 // parent ThreadGroup
407 static oop parent(oop java_thread_group);
408 // name
409 static typeArrayOop name(oop java_thread_group);
410 // ("name as oop" accessor is not necessary)
411 // Number of threads in group
412 static int nthreads(oop java_thread_group);
413 // threads
414 static objArrayOop threads(oop java_thread_group);
415 // Number of threads in group
416 static int ngroups(oop java_thread_group);
417 // groups
418 static objArrayOop groups(oop java_thread_group);
419 // maxPriority in group
420 static ThreadPriority maxPriority(oop java_thread_group);
421 // Destroyed
422 static bool is_destroyed(oop java_thread_group);
423 // Daemon
424 static bool is_daemon(oop java_thread_group);
425 // vmAllowSuspension
426 static bool is_vmAllowSuspension(oop java_thread_group);
427 // Debugging
428 friend class JavaClasses;
429 };
433 // Interface to java.lang.Throwable objects
435 class java_lang_Throwable: AllStatic {
436 friend class BacktraceBuilder;
438 private:
439 // Offsets
440 enum {
441 hc_backtrace_offset = 0,
442 hc_detailMessage_offset = 1,
443 hc_cause_offset = 2, // New since 1.4
444 hc_stackTrace_offset = 3 // New since 1.4
445 };
446 enum {
447 hc_static_unassigned_stacktrace_offset = 0 // New since 1.7
448 };
449 // Trace constants
450 enum {
451 trace_methods_offset = 0,
452 trace_bcis_offset = 1,
453 trace_mirrors_offset = 2,
454 trace_next_offset = 3,
455 trace_size = 4,
456 trace_chunk_size = 32
457 };
459 static int backtrace_offset;
460 static int detailMessage_offset;
461 static int cause_offset;
462 static int stackTrace_offset;
463 static int static_unassigned_stacktrace_offset;
465 // Printing
466 static char* print_stack_element_to_buffer(Handle mirror, int method, int version, int bci);
467 // StackTrace (programmatic access, new since 1.4)
468 static void clear_stacktrace(oop throwable);
469 // No stack trace available
470 static const char* no_stack_trace_message();
471 // Stacktrace (post JDK 1.7.0 to allow immutability protocol to be followed)
472 static void set_stacktrace(oop throwable, oop st_element_array);
473 static oop unassigned_stacktrace();
475 public:
476 // Backtrace
477 static oop backtrace(oop throwable);
478 static void set_backtrace(oop throwable, oop value);
479 // Needed by JVMTI to filter out this internal field.
480 static int get_backtrace_offset() { return backtrace_offset;}
481 static int get_detailMessage_offset() { return detailMessage_offset;}
482 // Message
483 static oop message(oop throwable);
484 static oop message(Handle throwable);
485 static void set_message(oop throwable, oop value);
486 static void print_stack_element(outputStream *st, Handle mirror, int method,
487 int version, int bci);
488 static void print_stack_element(outputStream *st, methodHandle method, int bci);
489 static void print_stack_usage(Handle stream);
491 // Allocate space for backtrace (created but stack trace not filled in)
492 static void allocate_backtrace(Handle throwable, TRAPS);
493 // Fill in current stack trace for throwable with preallocated backtrace (no GC)
494 static void fill_in_stack_trace_of_preallocated_backtrace(Handle throwable);
495 // Fill in current stack trace, can cause GC
496 static void fill_in_stack_trace(Handle throwable, methodHandle method, TRAPS);
497 static void fill_in_stack_trace(Handle throwable, methodHandle method = methodHandle());
498 // Programmatic access to stack trace
499 static oop get_stack_trace_element(oop throwable, int index, TRAPS);
500 static int get_stack_trace_depth(oop throwable, TRAPS);
501 // Printing
502 static void print(oop throwable, outputStream* st);
503 static void print(Handle throwable, outputStream* st);
504 static void print_stack_trace(oop throwable, outputStream* st);
505 // Debugging
506 friend class JavaClasses;
507 };
510 // Interface to java.lang.reflect.AccessibleObject objects
512 class java_lang_reflect_AccessibleObject: AllStatic {
513 private:
514 // Note that to reduce dependencies on the JDK we compute these
515 // offsets at run-time.
516 static int override_offset;
518 static void compute_offsets();
520 public:
521 // Accessors
522 static jboolean override(oop reflect);
523 static void set_override(oop reflect, jboolean value);
525 // Debugging
526 friend class JavaClasses;
527 };
530 // Interface to java.lang.reflect.Method objects
532 class java_lang_reflect_Method : public java_lang_reflect_AccessibleObject {
533 private:
534 // Note that to reduce dependencies on the JDK we compute these
535 // offsets at run-time.
536 static int clazz_offset;
537 static int name_offset;
538 static int returnType_offset;
539 static int parameterTypes_offset;
540 static int exceptionTypes_offset;
541 static int slot_offset;
542 static int modifiers_offset;
543 static int signature_offset;
544 static int annotations_offset;
545 static int parameter_annotations_offset;
546 static int annotation_default_offset;
547 static int type_annotations_offset;
549 static void compute_offsets();
551 public:
552 // Allocation
553 static Handle create(TRAPS);
555 // Accessors
556 static oop clazz(oop reflect);
557 static void set_clazz(oop reflect, oop value);
559 static oop name(oop method);
560 static void set_name(oop method, oop value);
562 static oop return_type(oop method);
563 static void set_return_type(oop method, oop value);
565 static oop parameter_types(oop method);
566 static void set_parameter_types(oop method, oop value);
568 static oop exception_types(oop method);
569 static void set_exception_types(oop method, oop value);
571 static int slot(oop reflect);
572 static void set_slot(oop reflect, int value);
574 static int modifiers(oop method);
575 static void set_modifiers(oop method, int value);
577 static bool has_signature_field();
578 static oop signature(oop method);
579 static void set_signature(oop method, oop value);
581 static bool has_annotations_field();
582 static oop annotations(oop method);
583 static void set_annotations(oop method, oop value);
585 static bool has_parameter_annotations_field();
586 static oop parameter_annotations(oop method);
587 static void set_parameter_annotations(oop method, oop value);
589 static bool has_annotation_default_field();
590 static oop annotation_default(oop method);
591 static void set_annotation_default(oop method, oop value);
593 static bool has_type_annotations_field();
594 static oop type_annotations(oop method);
595 static void set_type_annotations(oop method, oop value);
597 // Debugging
598 friend class JavaClasses;
599 };
602 // Interface to java.lang.reflect.Constructor objects
604 class java_lang_reflect_Constructor : public java_lang_reflect_AccessibleObject {
605 private:
606 // Note that to reduce dependencies on the JDK we compute these
607 // offsets at run-time.
608 static int clazz_offset;
609 static int parameterTypes_offset;
610 static int exceptionTypes_offset;
611 static int slot_offset;
612 static int modifiers_offset;
613 static int signature_offset;
614 static int annotations_offset;
615 static int parameter_annotations_offset;
616 static int type_annotations_offset;
618 static void compute_offsets();
620 public:
621 // Allocation
622 static Handle create(TRAPS);
624 // Accessors
625 static oop clazz(oop reflect);
626 static void set_clazz(oop reflect, oop value);
628 static oop parameter_types(oop constructor);
629 static void set_parameter_types(oop constructor, oop value);
631 static oop exception_types(oop constructor);
632 static void set_exception_types(oop constructor, oop value);
634 static int slot(oop reflect);
635 static void set_slot(oop reflect, int value);
637 static int modifiers(oop constructor);
638 static void set_modifiers(oop constructor, int value);
640 static bool has_signature_field();
641 static oop signature(oop constructor);
642 static void set_signature(oop constructor, oop value);
644 static bool has_annotations_field();
645 static oop annotations(oop constructor);
646 static void set_annotations(oop constructor, oop value);
648 static bool has_parameter_annotations_field();
649 static oop parameter_annotations(oop method);
650 static void set_parameter_annotations(oop method, oop value);
652 static bool has_type_annotations_field();
653 static oop type_annotations(oop constructor);
654 static void set_type_annotations(oop constructor, 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;
674 static int type_annotations_offset;
676 static void compute_offsets();
678 public:
679 // Allocation
680 static Handle create(TRAPS);
682 // Accessors
683 static oop clazz(oop reflect);
684 static void set_clazz(oop reflect, oop value);
686 static oop name(oop field);
687 static void set_name(oop field, oop value);
689 static oop type(oop field);
690 static void set_type(oop field, oop value);
692 static int slot(oop reflect);
693 static void set_slot(oop reflect, int value);
695 static int modifiers(oop field);
696 static void set_modifiers(oop field, int value);
698 static bool has_signature_field();
699 static oop signature(oop constructor);
700 static void set_signature(oop constructor, oop value);
702 static bool has_annotations_field();
703 static oop annotations(oop constructor);
704 static void set_annotations(oop constructor, oop value);
706 static bool has_parameter_annotations_field();
707 static oop parameter_annotations(oop method);
708 static void set_parameter_annotations(oop method, oop value);
710 static bool has_annotation_default_field();
711 static oop annotation_default(oop method);
712 static void set_annotation_default(oop method, oop value);
714 static bool has_type_annotations_field();
715 static oop type_annotations(oop field);
716 static void set_type_annotations(oop field, oop value);
718 // Debugging
719 friend class JavaClasses;
720 };
722 class java_lang_reflect_Parameter {
723 private:
724 // Note that to reduce dependencies on the JDK we compute these
725 // offsets at run-time.
726 static int name_offset;
727 static int modifiers_offset;
728 static int index_offset;
729 static int executable_offset;
731 static void compute_offsets();
733 public:
734 // Allocation
735 static Handle create(TRAPS);
737 // Accessors
738 static oop name(oop field);
739 static void set_name(oop field, oop value);
741 static int index(oop reflect);
742 static void set_index(oop reflect, int value);
744 static int modifiers(oop reflect);
745 static void set_modifiers(oop reflect, int value);
747 static oop executable(oop constructor);
748 static void set_executable(oop constructor, oop value);
750 friend class JavaClasses;
751 };
753 // Interface to sun.reflect.ConstantPool objects
754 class sun_reflect_ConstantPool {
755 private:
756 // Note that to reduce dependencies on the JDK we compute these
757 // offsets at run-time.
758 static int _oop_offset;
760 static void compute_offsets();
762 public:
763 // Allocation
764 static Handle create(TRAPS);
766 // Accessors
767 static void set_cp(oop reflect, ConstantPool* value);
768 static int oop_offset() {
769 return _oop_offset;
770 }
772 static ConstantPool* get_cp(oop reflect);
774 // Debugging
775 friend class JavaClasses;
776 };
778 // Interface to sun.reflect.UnsafeStaticFieldAccessorImpl objects
779 class sun_reflect_UnsafeStaticFieldAccessorImpl {
780 private:
781 static int _base_offset;
782 static void compute_offsets();
784 public:
785 static int base_offset() {
786 return _base_offset;
787 }
789 // Debugging
790 friend class JavaClasses;
791 };
793 // Interface to java.lang primitive type boxing objects:
794 // - java.lang.Boolean
795 // - java.lang.Character
796 // - java.lang.Float
797 // - java.lang.Double
798 // - java.lang.Byte
799 // - java.lang.Short
800 // - java.lang.Integer
801 // - java.lang.Long
803 // This could be separated out into 8 individual classes.
805 class java_lang_boxing_object: AllStatic {
806 private:
807 enum {
808 hc_value_offset = 0
809 };
810 static int value_offset;
811 static int long_value_offset;
813 static oop initialize_and_allocate(BasicType type, TRAPS);
814 public:
815 // Allocation. Returns a boxed value, or NULL for invalid type.
816 static oop create(BasicType type, jvalue* value, TRAPS);
817 // Accessors. Returns the basic type being boxed, or T_ILLEGAL for invalid oop.
818 static BasicType get_value(oop box, jvalue* value);
819 static BasicType set_value(oop box, jvalue* value);
820 static BasicType basic_type(oop box);
821 static bool is_instance(oop box) { return basic_type(box) != T_ILLEGAL; }
822 static bool is_instance(oop box, BasicType type) { return basic_type(box) == type; }
823 static void print(oop box, outputStream* st) { jvalue value; print(get_value(box, &value), &value, st); }
824 static void print(BasicType type, jvalue* value, outputStream* st);
826 static int value_offset_in_bytes(BasicType type) {
827 return ( type == T_LONG || type == T_DOUBLE ) ? long_value_offset :
828 value_offset;
829 }
831 // Debugging
832 friend class JavaClasses;
833 };
837 // Interface to java.lang.ref.Reference objects
839 class java_lang_ref_Reference: AllStatic {
840 public:
841 enum {
842 hc_referent_offset = 0,
843 hc_queue_offset = 1,
844 hc_next_offset = 2,
845 hc_discovered_offset = 3 // Is not last, see SoftRefs.
846 };
847 enum {
848 hc_static_lock_offset = 0,
849 hc_static_pending_offset = 1
850 };
852 static int referent_offset;
853 static int queue_offset;
854 static int next_offset;
855 static int discovered_offset;
856 static int static_lock_offset;
857 static int static_pending_offset;
858 static int number_of_fake_oop_fields;
860 // Accessors
861 static oop referent(oop ref) {
862 return ref->obj_field(referent_offset);
863 }
864 static void set_referent(oop ref, oop value) {
865 ref->obj_field_put(referent_offset, value);
866 }
867 static void set_referent_raw(oop ref, oop value) {
868 ref->obj_field_put_raw(referent_offset, value);
869 }
870 static HeapWord* referent_addr(oop ref) {
871 return ref->obj_field_addr<HeapWord>(referent_offset);
872 }
873 static oop next(oop ref) {
874 return ref->obj_field(next_offset);
875 }
876 static void set_next(oop ref, oop value) {
877 ref->obj_field_put(next_offset, value);
878 }
879 static void set_next_raw(oop ref, oop value) {
880 ref->obj_field_put_raw(next_offset, value);
881 }
882 static HeapWord* next_addr(oop ref) {
883 return ref->obj_field_addr<HeapWord>(next_offset);
884 }
885 static oop discovered(oop ref) {
886 return ref->obj_field(discovered_offset);
887 }
888 static void set_discovered(oop ref, oop value) {
889 ref->obj_field_put(discovered_offset, value);
890 }
891 static void set_discovered_raw(oop ref, oop value) {
892 ref->obj_field_put_raw(discovered_offset, value);
893 }
894 static HeapWord* discovered_addr(oop ref) {
895 return ref->obj_field_addr<HeapWord>(discovered_offset);
896 }
897 // Accessors for statics
898 static oop pending_list_lock();
899 static oop pending_list();
901 static HeapWord* pending_list_lock_addr();
902 static HeapWord* pending_list_addr();
903 };
906 // Interface to java.lang.ref.SoftReference objects
908 class java_lang_ref_SoftReference: public java_lang_ref_Reference {
909 public:
910 enum {
911 // The timestamp is a long field and may need to be adjusted for alignment.
912 hc_timestamp_offset = hc_discovered_offset + 1
913 };
914 enum {
915 hc_static_clock_offset = 0
916 };
918 static int timestamp_offset;
919 static int static_clock_offset;
921 // Accessors
922 static jlong timestamp(oop ref);
924 // Accessors for statics
925 static jlong clock();
926 static void set_clock(jlong value);
927 };
930 // Interface to java.lang.invoke.MethodHandle objects
932 class MethodHandleEntry;
934 class java_lang_invoke_MethodHandle: AllStatic {
935 friend class JavaClasses;
937 private:
938 static int _type_offset; // the MethodType of this MH
939 static int _form_offset; // the LambdaForm of this MH
941 static void compute_offsets();
943 public:
944 // Accessors
945 static oop type(oop mh);
946 static void set_type(oop mh, oop mtype);
948 static oop form(oop mh);
949 static void set_form(oop mh, oop lform);
951 // Testers
952 static bool is_subclass(Klass* klass) {
953 return klass->is_subclass_of(SystemDictionary::MethodHandle_klass());
954 }
955 static bool is_instance(oop obj) {
956 return obj != NULL && is_subclass(obj->klass());
957 }
959 // Accessors for code generation:
960 static int type_offset_in_bytes() { return _type_offset; }
961 static int form_offset_in_bytes() { return _form_offset; }
962 };
964 // Interface to java.lang.invoke.LambdaForm objects
965 // (These are a private interface for managing adapter code generation.)
967 class java_lang_invoke_LambdaForm: AllStatic {
968 friend class JavaClasses;
970 private:
971 static int _vmentry_offset; // type is MemberName
973 static void compute_offsets();
975 public:
976 // Accessors
977 static oop vmentry(oop lform);
978 static void set_vmentry(oop lform, oop invoker);
980 // Testers
981 static bool is_subclass(Klass* klass) {
982 return SystemDictionary::LambdaForm_klass() != NULL &&
983 klass->is_subclass_of(SystemDictionary::LambdaForm_klass());
984 }
985 static bool is_instance(oop obj) {
986 return obj != NULL && is_subclass(obj->klass());
987 }
989 // Accessors for code generation:
990 static int vmentry_offset_in_bytes() { return _vmentry_offset; }
991 };
994 // Interface to java.lang.invoke.MemberName objects
995 // (These are a private interface for Java code to query the class hierarchy.)
997 #define MEMBERNAME_INJECTED_FIELDS(macro) \
998 macro(java_lang_invoke_MemberName, vmloader, object_signature, false) \
999 macro(java_lang_invoke_MemberName, vmindex, intptr_signature, false) \
1000 macro(java_lang_invoke_MemberName, vmtarget, intptr_signature, false)
1002 class java_lang_invoke_MemberName: AllStatic {
1003 friend class JavaClasses;
1005 private:
1006 // From java.lang.invoke.MemberName:
1007 // private Class<?> clazz; // class in which the method is defined
1008 // private String name; // may be null if not yet materialized
1009 // private Object type; // may be null if not yet materialized
1010 // private int flags; // modifier bits; see reflect.Modifier
1011 // private intptr vmtarget; // VM-specific target value
1012 // private intptr_t vmindex; // member index within class or interface
1013 static int _clazz_offset;
1014 static int _name_offset;
1015 static int _type_offset;
1016 static int _flags_offset;
1017 static int _vmtarget_offset;
1018 static int _vmloader_offset;
1019 static int _vmindex_offset;
1021 static void compute_offsets();
1023 public:
1024 // Accessors
1025 static oop clazz(oop mname);
1026 static void set_clazz(oop mname, oop clazz);
1028 static oop type(oop mname);
1029 static void set_type(oop mname, oop type);
1031 static oop name(oop mname);
1032 static void set_name(oop mname, oop name);
1034 static int flags(oop mname);
1035 static void set_flags(oop mname, int flags);
1037 static Metadata* vmtarget(oop mname);
1038 static void set_vmtarget(oop mname, Metadata* target);
1039 #if INCLUDE_JVMTI
1040 static void adjust_vmtarget(oop mname, Metadata* target);
1041 #endif // INCLUDE_JVMTI
1043 static intptr_t vmindex(oop mname);
1044 static void set_vmindex(oop mname, intptr_t index);
1046 // Testers
1047 static bool is_subclass(Klass* klass) {
1048 return klass->is_subclass_of(SystemDictionary::MemberName_klass());
1049 }
1050 static bool is_instance(oop obj) {
1051 return obj != NULL && is_subclass(obj->klass());
1052 }
1054 // Relevant integer codes (keep these in synch. with MethodHandleNatives.Constants):
1055 enum {
1056 MN_IS_METHOD = 0x00010000, // method (not constructor)
1057 MN_IS_CONSTRUCTOR = 0x00020000, // constructor
1058 MN_IS_FIELD = 0x00040000, // field
1059 MN_IS_TYPE = 0x00080000, // nested type
1060 MN_CALLER_SENSITIVE = 0x00100000, // @CallerSensitive annotation detected
1061 MN_REFERENCE_KIND_SHIFT = 24, // refKind
1062 MN_REFERENCE_KIND_MASK = 0x0F000000 >> MN_REFERENCE_KIND_SHIFT,
1063 // The SEARCH_* bits are not for MN.flags but for the matchFlags argument of MHN.getMembers:
1064 MN_SEARCH_SUPERCLASSES = 0x00100000, // walk super classes
1065 MN_SEARCH_INTERFACES = 0x00200000 // walk implemented interfaces
1066 };
1068 // Accessors for code generation:
1069 static int clazz_offset_in_bytes() { return _clazz_offset; }
1070 static int type_offset_in_bytes() { return _type_offset; }
1071 static int name_offset_in_bytes() { return _name_offset; }
1072 static int flags_offset_in_bytes() { return _flags_offset; }
1073 static int vmtarget_offset_in_bytes() { return _vmtarget_offset; }
1074 static int vmindex_offset_in_bytes() { return _vmindex_offset; }
1075 };
1078 // Interface to java.lang.invoke.MethodType objects
1080 class java_lang_invoke_MethodType: AllStatic {
1081 friend class JavaClasses;
1083 private:
1084 static int _rtype_offset;
1085 static int _ptypes_offset;
1087 static void compute_offsets();
1089 public:
1090 // Accessors
1091 static oop rtype(oop mt);
1092 static objArrayOop ptypes(oop mt);
1094 static oop ptype(oop mt, int index);
1095 static int ptype_count(oop mt);
1097 static int ptype_slot_count(oop mt); // extra counts for long/double
1098 static int rtype_slot_count(oop mt); // extra counts for long/double
1100 static Symbol* as_signature(oop mt, bool intern_if_not_found, TRAPS);
1101 static void print_signature(oop mt, outputStream* st);
1103 static bool is_instance(oop obj) {
1104 return obj != NULL && obj->klass() == SystemDictionary::MethodType_klass();
1105 }
1107 static bool equals(oop mt1, oop mt2);
1109 // Accessors for code generation:
1110 static int rtype_offset_in_bytes() { return _rtype_offset; }
1111 static int ptypes_offset_in_bytes() { return _ptypes_offset; }
1112 };
1115 // Interface to java.lang.invoke.CallSite objects
1117 class java_lang_invoke_CallSite: AllStatic {
1118 friend class JavaClasses;
1120 private:
1121 static int _target_offset;
1123 static void compute_offsets();
1125 public:
1126 // Accessors
1127 static oop target( oop site) { return site->obj_field( _target_offset); }
1128 static void set_target( oop site, oop target) { site->obj_field_put( _target_offset, target); }
1130 static volatile oop target_volatile(oop site) { return site->obj_field_volatile( _target_offset); }
1131 static void set_target_volatile(oop site, oop target) { site->obj_field_put_volatile(_target_offset, target); }
1133 // Testers
1134 static bool is_subclass(Klass* klass) {
1135 return klass->is_subclass_of(SystemDictionary::CallSite_klass());
1136 }
1137 static bool is_instance(oop obj) {
1138 return obj != NULL && is_subclass(obj->klass());
1139 }
1141 // Accessors for code generation:
1142 static int target_offset_in_bytes() { return _target_offset; }
1143 };
1146 // Interface to java.security.AccessControlContext objects
1148 class java_security_AccessControlContext: AllStatic {
1149 private:
1150 // Note that for this class the layout changed between JDK1.2 and JDK1.3,
1151 // so we compute the offsets at startup rather than hard-wiring them.
1152 static int _context_offset;
1153 static int _privilegedContext_offset;
1154 static int _isPrivileged_offset;
1156 static void compute_offsets();
1157 public:
1158 static oop create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS);
1160 // Debugging/initialization
1161 friend class JavaClasses;
1162 };
1165 // Interface to java.lang.ClassLoader objects
1167 #define CLASSLOADER_INJECTED_FIELDS(macro) \
1168 macro(java_lang_ClassLoader, loader_data, intptr_signature, false)
1170 class java_lang_ClassLoader : AllStatic {
1171 private:
1172 // The fake offsets are added by the class loader when java.lang.Class is loaded
1173 enum {
1174 hc_parent_offset = 0
1175 };
1176 static int _loader_data_offset;
1177 static bool offsets_computed;
1178 static int parent_offset;
1179 static int parallelCapable_offset;
1181 public:
1182 static void compute_offsets();
1184 static ClassLoaderData** loader_data_addr(oop loader);
1185 static ClassLoaderData* loader_data(oop loader);
1187 static oop parent(oop loader);
1188 static bool isAncestor(oop loader, oop cl);
1190 // Support for parallelCapable field
1191 static bool parallelCapable(oop the_class_mirror);
1193 static bool is_trusted_loader(oop loader);
1195 // Fix for 4474172
1196 static oop non_reflection_class_loader(oop loader);
1198 // Testers
1199 static bool is_subclass(Klass* klass) {
1200 return klass->is_subclass_of(SystemDictionary::ClassLoader_klass());
1201 }
1202 static bool is_instance(oop obj) {
1203 return obj != NULL && is_subclass(obj->klass());
1204 }
1206 // Debugging
1207 friend class JavaClasses;
1208 friend class ClassFileParser; // access to number_of_fake_fields
1209 };
1212 // Interface to java.lang.System objects
1214 class java_lang_System : AllStatic {
1215 private:
1216 enum {
1217 hc_static_in_offset = 0,
1218 hc_static_out_offset = 1,
1219 hc_static_err_offset = 2
1220 };
1222 static int static_in_offset;
1223 static int static_out_offset;
1224 static int static_err_offset;
1226 public:
1227 static int in_offset_in_bytes();
1228 static int out_offset_in_bytes();
1229 static int err_offset_in_bytes();
1231 // Debugging
1232 friend class JavaClasses;
1233 };
1236 // Interface to java.lang.StackTraceElement objects
1238 class java_lang_StackTraceElement: AllStatic {
1239 private:
1240 enum {
1241 hc_declaringClass_offset = 0,
1242 hc_methodName_offset = 1,
1243 hc_fileName_offset = 2,
1244 hc_lineNumber_offset = 3
1245 };
1247 static int declaringClass_offset;
1248 static int methodName_offset;
1249 static int fileName_offset;
1250 static int lineNumber_offset;
1252 public:
1253 // Setters
1254 static void set_declaringClass(oop element, oop value);
1255 static void set_methodName(oop element, oop value);
1256 static void set_fileName(oop element, oop value);
1257 static void set_lineNumber(oop element, int value);
1259 // Create an instance of StackTraceElement
1260 static oop create(Handle mirror, int method, int version, int bci, TRAPS);
1261 static oop create(methodHandle method, int bci, TRAPS);
1263 // Debugging
1264 friend class JavaClasses;
1265 };
1268 // Interface to java.lang.AssertionStatusDirectives objects
1270 class java_lang_AssertionStatusDirectives: AllStatic {
1271 private:
1272 enum {
1273 hc_classes_offset,
1274 hc_classEnabled_offset,
1275 hc_packages_offset,
1276 hc_packageEnabled_offset,
1277 hc_deflt_offset
1278 };
1280 static int classes_offset;
1281 static int classEnabled_offset;
1282 static int packages_offset;
1283 static int packageEnabled_offset;
1284 static int deflt_offset;
1286 public:
1287 // Setters
1288 static void set_classes(oop obj, oop val);
1289 static void set_classEnabled(oop obj, oop val);
1290 static void set_packages(oop obj, oop val);
1291 static void set_packageEnabled(oop obj, oop val);
1292 static void set_deflt(oop obj, bool val);
1293 // Debugging
1294 friend class JavaClasses;
1295 };
1298 class java_nio_Buffer: AllStatic {
1299 private:
1300 static int _limit_offset;
1302 public:
1303 static int limit_offset();
1304 static void compute_offsets();
1305 };
1307 class java_util_concurrent_locks_AbstractOwnableSynchronizer : AllStatic {
1308 private:
1309 static int _owner_offset;
1310 public:
1311 static void initialize(TRAPS);
1312 static oop get_owner_threadObj(oop obj);
1313 };
1315 // Use to declare fields that need to be injected into Java classes
1316 // for the JVM to use. The name_index and signature_index are
1317 // declared in vmSymbols. The may_be_java flag is used to declare
1318 // fields that might already exist in Java but should be injected if
1319 // they don't. Otherwise the field is unconditionally injected and
1320 // the JVM uses the injected one. This is to ensure that name
1321 // collisions don't occur. In general may_be_java should be false
1322 // unless there's a good reason.
1324 class InjectedField {
1325 public:
1326 const SystemDictionary::WKID klass_id;
1327 const vmSymbols::SID name_index;
1328 const vmSymbols::SID signature_index;
1329 const bool may_be_java;
1332 Klass* klass() const { return SystemDictionary::well_known_klass(klass_id); }
1333 Symbol* name() const { return lookup_symbol(name_index); }
1334 Symbol* signature() const { return lookup_symbol(signature_index); }
1336 int compute_offset();
1338 // Find the Symbol for this index
1339 static Symbol* lookup_symbol(int symbol_index) {
1340 return vmSymbols::symbol_at((vmSymbols::SID)symbol_index);
1341 }
1342 };
1344 #define DECLARE_INJECTED_FIELD_ENUM(klass, name, signature, may_be_java) \
1345 klass##_##name##_enum,
1347 #define ALL_INJECTED_FIELDS(macro) \
1348 CLASS_INJECTED_FIELDS(macro) \
1349 CLASSLOADER_INJECTED_FIELDS(macro) \
1350 MEMBERNAME_INJECTED_FIELDS(macro)
1352 // Interface to hard-coded offset checking
1354 class JavaClasses : AllStatic {
1355 private:
1357 static InjectedField _injected_fields[];
1359 static bool check_offset(const char *klass_name, int offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
1360 static bool check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
1361 static bool check_constant(const char *klass_name, int constant, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
1363 public:
1364 enum InjectedFieldID {
1365 ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD_ENUM)
1366 MAX_enum
1367 };
1369 static int compute_injected_offset(InjectedFieldID id);
1371 static void compute_hard_coded_offsets();
1372 static void compute_offsets();
1373 static void check_offsets() PRODUCT_RETURN;
1375 static InjectedField* get_injected(Symbol* class_name, int* field_count);
1376 };
1378 #undef DECLARE_INJECTED_FIELD_ENUM
1380 #endif // SHARE_VM_CLASSFILE_JAVACLASSES_HPP