javaClasses.hpp revision 0:a61af66fc99e 
1/*
2 * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25// Interface for manipulating the basic Java classes.
26//
27// All dependencies on layout of actual Java classes should be kept here.
28// If the layout of any of the classes above changes the offsets must be adjusted.
29//
30// For most classes we hardwire the offsets for performance reasons. In certain
31// cases (e.g. java.security.AccessControlContext) we compute the offsets at
32// startup since the layout here differs between JDK1.2 and JDK1.3.
33//
34// Note that fields (static and non-static) are arranged with oops before non-oops
35// on a per class basis. The offsets below have to reflect this ordering.
36//
37// When editing the layouts please update the check_offset verification code
38// correspondingly. The names in the enums must be identical to the actual field
39// names in order for the verification code to work.
40
41
42// Interface to java.lang.String objects
43
44class java_lang_String : AllStatic {
45 private:
46  enum {
47    hc_value_offset  = 0,
48    hc_offset_offset = 1,
49    hc_count_offset  = 2,
50    hc_hash_offset   = 3
51  };
52
53  static int value_offset;
54  static int offset_offset;
55  static int count_offset;
56  static int hash_offset;
57
58  static Handle basic_create(int length, bool tenured, TRAPS);
59  static Handle basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS);
60
61  static void set_value( oop string, typeArrayOop buffer) { string->obj_field_put(value_offset,  (oop)buffer); }
62  static void set_offset(oop string, int offset)          { string->int_field_put(offset_offset, offset); }
63  static void set_count( oop string, int count)           { string->int_field_put(count_offset,  count);  }
64
65 public:
66  // Instance creation
67  static Handle create_from_unicode(jchar* unicode, int len, TRAPS);
68  static Handle create_tenured_from_unicode(jchar* unicode, int len, TRAPS);
69  static oop    create_oop_from_unicode(jchar* unicode, int len, TRAPS);
70  static Handle create_from_str(const char* utf8_str, TRAPS);
71  static oop    create_oop_from_str(const char* utf8_str, TRAPS);
72  static Handle create_from_symbol(symbolHandle symbol, TRAPS);
73  static Handle create_from_platform_dependent_str(const char* str, TRAPS);
74  static Handle char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS);
75
76  static int value_offset_in_bytes()  { return value_offset;  }
77  static int count_offset_in_bytes()  { return count_offset;  }
78  static int offset_offset_in_bytes() { return offset_offset; }
79  static int hash_offset_in_bytes()   { return hash_offset;   }
80
81  // Accessors
82  static typeArrayOop value(oop java_string) {
83    assert(is_instance(java_string), "must be java_string");
84    return (typeArrayOop) java_string->obj_field(value_offset);
85  }
86  static int offset(oop java_string) {
87    assert(is_instance(java_string), "must be java_string");
88    return java_string->int_field(offset_offset);
89  }
90  static int length(oop java_string) {
91    assert(is_instance(java_string), "must be java_string");
92    return java_string->int_field(count_offset);
93  }
94  static int utf8_length(oop java_string);
95
96  // String converters
97  static char*  as_utf8_string(oop java_string);
98  static char*  as_utf8_string(oop java_string, int start, int len);
99  static jchar* as_unicode_string(oop java_string, int& length);
100
101  static bool equals(oop java_string, jchar* chars, int len);
102
103  // Conversion between '.' and '/' formats
104  static Handle externalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '/', '.', THREAD); }
105  static Handle internalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '.', '/', THREAD); }
106
107  // Conversion
108  static symbolHandle as_symbol(Handle java_string, TRAPS);
109
110  // Testers
111  static bool is_instance(oop obj) {
112    return obj != NULL && obj->klass() == SystemDictionary::string_klass();
113  }
114
115  // Debugging
116  static void print(Handle java_string, outputStream* st);
117  friend class JavaClasses;
118};
119
120
121// Interface to java.lang.Class objects
122
123class java_lang_Class : AllStatic {
124   friend class VMStructs;
125 private:
126  // The fake offsets are added by the class loader when java.lang.Class is loaded
127
128  enum {
129    hc_klass_offset                = 0,
130    hc_array_klass_offset          = 1,
131    hc_resolved_constructor_offset = 2,
132    hc_number_of_fake_oop_fields   = 3
133  };
134
135  static int klass_offset;
136  static int resolved_constructor_offset;
137  static int array_klass_offset;
138  static int number_of_fake_oop_fields;
139
140  static void compute_offsets();
141  static bool offsets_computed;
142  static int classRedefinedCount_offset;
143
144 public:
145  // Instance creation
146  static oop  create_mirror(KlassHandle k, TRAPS);
147  static oop  create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS);
148  // Conversion
149  static klassOop as_klassOop(oop java_class);
150  // Testing
151  static bool is_primitive(oop java_class);
152  static BasicType primitive_type(oop java_class);
153  static oop primitive_mirror(BasicType t);
154  // JVM_NewInstance support
155  static methodOop resolved_constructor(oop java_class);
156  static void set_resolved_constructor(oop java_class, methodOop constructor);
157  // JVM_NewArray support
158  static klassOop array_klass(oop java_class);
159  static void set_array_klass(oop java_class, klassOop klass);
160  // compiler support for class operations
161  static int klass_offset_in_bytes() { return klass_offset; }
162  static int resolved_constructor_offset_in_bytes() { return resolved_constructor_offset; }
163  static int array_klass_offset_in_bytes() { return array_klass_offset; }
164  // Support for classRedefinedCount field
165  static int classRedefinedCount(oop the_class_mirror);
166  static void set_classRedefinedCount(oop the_class_mirror, int value);
167  // Debugging
168  friend class JavaClasses;
169  friend class instanceKlass;   // verification code accesses offsets
170  friend class ClassFileParser; // access to number_of_fake_fields
171};
172
173// Interface to java.lang.Thread objects
174
175class java_lang_Thread : AllStatic {
176 private:
177  // Note that for this class the layout changed between JDK1.2 and JDK1.3,
178  // so we compute the offsets at startup rather than hard-wiring them.
179  static int _name_offset;
180  static int _group_offset;
181  static int _contextClassLoader_offset;
182  static int _inheritedAccessControlContext_offset;
183  static int _priority_offset;
184  static int _eetop_offset;
185  static int _daemon_offset;
186  static int _stillborn_offset;
187  static int _stackSize_offset;
188  static int _tid_offset;
189  static int _thread_status_offset;
190  static int _park_blocker_offset;
191  static int _park_event_offset ;
192
193  static void compute_offsets();
194
195 public:
196  // Instance creation
197  static oop create();
198  // Returns the JavaThread associated with the thread obj
199  static JavaThread* thread(oop java_thread);
200  // Set JavaThread for instance
201  static void set_thread(oop java_thread, JavaThread* thread);
202  // Name
203  static typeArrayOop name(oop java_thread);
204  static void set_name(oop java_thread, typeArrayOop name);
205  // Priority
206  static ThreadPriority priority(oop java_thread);
207  static void set_priority(oop java_thread, ThreadPriority priority);
208  // Thread group
209  static oop  threadGroup(oop java_thread);
210  // Stillborn
211  static bool is_stillborn(oop java_thread);
212  static void set_stillborn(oop java_thread);
213  // Alive (NOTE: this is not really a field, but provides the correct
214  // definition without doing a Java call)
215  static bool is_alive(oop java_thread);
216  // Daemon
217  static bool is_daemon(oop java_thread);
218  static void set_daemon(oop java_thread);
219  // Context ClassLoader
220  static oop context_class_loader(oop java_thread);
221  // Control context
222  static oop inherited_access_control_context(oop java_thread);
223  // Stack size hint
224  static jlong stackSize(oop java_thread);
225  // Thread ID
226  static jlong thread_id(oop java_thread);
227
228  // Blocker object responsible for thread parking
229  static oop park_blocker(oop java_thread);
230
231  // Pointer to type-stable park handler, encoded as jlong.
232  // Should be set when apparently null
233  // For details, see unsafe.cpp Unsafe_Unpark
234  static jlong park_event(oop java_thread);
235  static bool set_park_event(oop java_thread, jlong ptr);
236
237  // Java Thread Status for JVMTI and M&M use.
238  // This thread status info is saved in threadStatus field of
239  // java.lang.Thread java class.
240  enum ThreadStatus {
241    NEW                      = 0,
242    RUNNABLE                 = JVMTI_THREAD_STATE_ALIVE +          // runnable / running
243                               JVMTI_THREAD_STATE_RUNNABLE,
244    SLEEPING                 = JVMTI_THREAD_STATE_ALIVE +          // Thread.sleep()
245                               JVMTI_THREAD_STATE_WAITING +
246                               JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
247                               JVMTI_THREAD_STATE_SLEEPING,
248    IN_OBJECT_WAIT           = JVMTI_THREAD_STATE_ALIVE +          // Object.wait()
249                               JVMTI_THREAD_STATE_WAITING +
250                               JVMTI_THREAD_STATE_WAITING_INDEFINITELY +
251                               JVMTI_THREAD_STATE_IN_OBJECT_WAIT,
252    IN_OBJECT_WAIT_TIMED     = JVMTI_THREAD_STATE_ALIVE +          // Object.wait(long)
253                               JVMTI_THREAD_STATE_WAITING +
254                               JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
255                               JVMTI_THREAD_STATE_IN_OBJECT_WAIT,
256    PARKED                   = JVMTI_THREAD_STATE_ALIVE +          // LockSupport.park()
257                               JVMTI_THREAD_STATE_WAITING +
258                               JVMTI_THREAD_STATE_WAITING_INDEFINITELY +
259                               JVMTI_THREAD_STATE_PARKED,
260    PARKED_TIMED             = JVMTI_THREAD_STATE_ALIVE +          // LockSupport.park(long)
261                               JVMTI_THREAD_STATE_WAITING +
262                               JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
263                               JVMTI_THREAD_STATE_PARKED,
264    BLOCKED_ON_MONITOR_ENTER = JVMTI_THREAD_STATE_ALIVE +          // (re-)entering a synchronization block
265                               JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER,
266    TERMINATED               = JVMTI_THREAD_STATE_TERMINATED
267  };
268  // Write thread status info to threadStatus field of java.lang.Thread.
269  static void set_thread_status(oop java_thread_oop, ThreadStatus status);
270  // Read thread status info from threadStatus field of java.lang.Thread.
271  static ThreadStatus get_thread_status(oop java_thread_oop);
272
273  static const char*  thread_status_name(oop java_thread_oop);
274
275  // Debugging
276  friend class JavaClasses;
277};
278
279// Interface to java.lang.ThreadGroup objects
280
281class java_lang_ThreadGroup : AllStatic {
282 private:
283  static int _parent_offset;
284  static int _name_offset;
285  static int _threads_offset;
286  static int _groups_offset;
287  static int _maxPriority_offset;
288  static int _destroyed_offset;
289  static int _daemon_offset;
290  static int _vmAllowSuspension_offset;
291  static int _nthreads_offset;
292  static int _ngroups_offset;
293
294  static void compute_offsets();
295
296 public:
297  // parent ThreadGroup
298  static oop  parent(oop java_thread_group);
299  // name
300  static typeArrayOop name(oop java_thread_group);
301  // ("name as oop" accessor is not necessary)
302  // Number of threads in group
303  static int nthreads(oop java_thread_group);
304  // threads
305  static objArrayOop threads(oop java_thread_group);
306  // Number of threads in group
307  static int ngroups(oop java_thread_group);
308  // groups
309  static objArrayOop groups(oop java_thread_group);
310  // maxPriority in group
311  static ThreadPriority maxPriority(oop java_thread_group);
312  // Destroyed
313  static bool is_destroyed(oop java_thread_group);
314  // Daemon
315  static bool is_daemon(oop java_thread_group);
316  // vmAllowSuspension
317  static bool is_vmAllowSuspension(oop java_thread_group);
318  // Debugging
319  friend class JavaClasses;
320};
321
322
323
324// Interface to java.lang.Throwable objects
325
326class java_lang_Throwable: AllStatic {
327  friend class BacktraceBuilder;
328
329 private:
330  // Offsets
331  enum {
332    hc_backtrace_offset     =  0,
333    hc_detailMessage_offset =  1,
334    hc_cause_offset         =  2,  // New since 1.4
335    hc_stackTrace_offset    =  3   // New since 1.4
336  };
337  // Trace constants
338  enum {
339    trace_methods_offset = 0,
340    trace_bcis_offset    = 1,
341    trace_next_offset    = 2,
342    trace_size           = 3,
343    trace_chunk_size     = 32
344  };
345
346  static int backtrace_offset;
347  static int detailMessage_offset;
348  static int cause_offset;
349  static int stackTrace_offset;
350
351  // Printing
352  static char* print_stack_element_to_buffer(methodOop method, int bci);
353  static void print_to_stream(Handle stream, const char* str);
354  // StackTrace (programmatic access, new since 1.4)
355  static void clear_stacktrace(oop throwable);
356  // No stack trace available
357  static const char* no_stack_trace_message();
358
359 public:
360  // Backtrace
361  static oop backtrace(oop throwable);
362  static void set_backtrace(oop throwable, oop value);
363  // Needed by JVMTI to filter out this internal field.
364  static int get_backtrace_offset() { return backtrace_offset;}
365  static int get_detailMessage_offset() { return detailMessage_offset;}
366  // Message
367  static oop message(oop throwable);
368  static oop message(Handle throwable);
369  static void set_message(oop throwable, oop value);
370  // Print stack trace stored in exception by call-back to Java
371  // Note: this is no longer used in Merlin, but we still suppport
372  // it for compatibility.
373  static void print_stack_trace(oop throwable, oop print_stream);
374  static void print_stack_element(Handle stream, methodOop method, int bci);
375  static void print_stack_element(outputStream *st, methodOop method, int bci);
376  static void print_stack_usage(Handle stream);
377
378  // Allocate space for backtrace (created but stack trace not filled in)
379  static void allocate_backtrace(Handle throwable, TRAPS);
380  // Fill in current stack trace for throwable with preallocated backtrace (no GC)
381  static void fill_in_stack_trace_of_preallocated_backtrace(Handle throwable);
382
383  // Fill in current stack trace, can cause GC
384  static void fill_in_stack_trace(Handle throwable, TRAPS);
385  static void fill_in_stack_trace(Handle throwable);
386  // Programmatic access to stack trace
387  static oop  get_stack_trace_element(oop throwable, int index, TRAPS);
388  static int  get_stack_trace_depth(oop throwable, TRAPS);
389  // Printing
390  static void print(oop throwable, outputStream* st);
391  static void print(Handle throwable, outputStream* st);
392  static void print_stack_trace(oop throwable, outputStream* st);
393  // Debugging
394  friend class JavaClasses;
395};
396
397
398// Interface to java.lang.reflect.AccessibleObject objects
399
400class java_lang_reflect_AccessibleObject: AllStatic {
401 private:
402  // Note that to reduce dependencies on the JDK we compute these
403  // offsets at run-time.
404  static int override_offset;
405
406  static void compute_offsets();
407
408 public:
409  // Accessors
410  static jboolean override(oop reflect);
411  static void set_override(oop reflect, jboolean value);
412
413  // Debugging
414  friend class JavaClasses;
415};
416
417
418// Interface to java.lang.reflect.Method objects
419
420class java_lang_reflect_Method : public java_lang_reflect_AccessibleObject {
421 private:
422  // Note that to reduce dependencies on the JDK we compute these
423  // offsets at run-time.
424  static int clazz_offset;
425  static int name_offset;
426  static int returnType_offset;
427  static int parameterTypes_offset;
428  static int exceptionTypes_offset;
429  static int slot_offset;
430  static int modifiers_offset;
431  static int signature_offset;
432  static int annotations_offset;
433  static int parameter_annotations_offset;
434  static int annotation_default_offset;
435
436  static void compute_offsets();
437
438 public:
439  // Allocation
440  static Handle create(TRAPS);
441
442  // Accessors
443  static oop clazz(oop reflect);
444  static void set_clazz(oop reflect, oop value);
445
446  static oop name(oop method);
447  static void set_name(oop method, oop value);
448
449  static oop return_type(oop method);
450  static void set_return_type(oop method, oop value);
451
452  static oop parameter_types(oop method);
453  static void set_parameter_types(oop method, oop value);
454
455  static oop exception_types(oop method);
456  static void set_exception_types(oop method, oop value);
457
458  static int slot(oop reflect);
459  static void set_slot(oop reflect, int value);
460
461  static int modifiers(oop method);
462  static void set_modifiers(oop method, int value);
463
464  static bool has_signature_field();
465  static oop signature(oop method);
466  static void set_signature(oop method, oop value);
467
468  static bool has_annotations_field();
469  static oop annotations(oop method);
470  static void set_annotations(oop method, oop value);
471
472  static bool has_parameter_annotations_field();
473  static oop parameter_annotations(oop method);
474  static void set_parameter_annotations(oop method, oop value);
475
476  static bool has_annotation_default_field();
477  static oop annotation_default(oop method);
478  static void set_annotation_default(oop method, oop value);
479
480  // Debugging
481  friend class JavaClasses;
482};
483
484
485// Interface to java.lang.reflect.Constructor objects
486
487class java_lang_reflect_Constructor : public java_lang_reflect_AccessibleObject {
488 private:
489  // Note that to reduce dependencies on the JDK we compute these
490  // offsets at run-time.
491  static int clazz_offset;
492  static int parameterTypes_offset;
493  static int exceptionTypes_offset;
494  static int slot_offset;
495  static int modifiers_offset;
496  static int signature_offset;
497  static int annotations_offset;
498  static int parameter_annotations_offset;
499
500  static void compute_offsets();
501
502 public:
503  // Allocation
504  static Handle create(TRAPS);
505
506  // Accessors
507  static oop clazz(oop reflect);
508  static void set_clazz(oop reflect, oop value);
509
510  static oop parameter_types(oop constructor);
511  static void set_parameter_types(oop constructor, oop value);
512
513  static oop exception_types(oop constructor);
514  static void set_exception_types(oop constructor, oop value);
515
516  static int slot(oop reflect);
517  static void set_slot(oop reflect, int value);
518
519  static int modifiers(oop constructor);
520  static void set_modifiers(oop constructor, int value);
521
522  static bool has_signature_field();
523  static oop signature(oop constructor);
524  static void set_signature(oop constructor, oop value);
525
526  static bool has_annotations_field();
527  static oop annotations(oop constructor);
528  static void set_annotations(oop constructor, oop value);
529
530  static bool has_parameter_annotations_field();
531  static oop parameter_annotations(oop method);
532  static void set_parameter_annotations(oop method, oop value);
533
534  // Debugging
535  friend class JavaClasses;
536};
537
538
539// Interface to java.lang.reflect.Field objects
540
541class java_lang_reflect_Field : public java_lang_reflect_AccessibleObject {
542 private:
543  // Note that to reduce dependencies on the JDK we compute these
544  // offsets at run-time.
545  static int clazz_offset;
546  static int name_offset;
547  static int type_offset;
548  static int slot_offset;
549  static int modifiers_offset;
550  static int signature_offset;
551  static int annotations_offset;
552
553  static void compute_offsets();
554
555 public:
556  // Allocation
557  static Handle create(TRAPS);
558
559  // Accessors
560  static oop clazz(oop reflect);
561  static void set_clazz(oop reflect, oop value);
562
563  static oop name(oop field);
564  static void set_name(oop field, oop value);
565
566  static oop type(oop field);
567  static void set_type(oop field, oop value);
568
569  static int slot(oop reflect);
570  static void set_slot(oop reflect, int value);
571
572  static int modifiers(oop field);
573  static void set_modifiers(oop field, int value);
574
575  static bool has_signature_field();
576  static oop signature(oop constructor);
577  static void set_signature(oop constructor, oop value);
578
579  static bool has_annotations_field();
580  static oop annotations(oop constructor);
581  static void set_annotations(oop constructor, oop value);
582
583  static bool has_parameter_annotations_field();
584  static oop parameter_annotations(oop method);
585  static void set_parameter_annotations(oop method, oop value);
586
587  static bool has_annotation_default_field();
588  static oop annotation_default(oop method);
589  static void set_annotation_default(oop method, oop value);
590
591  // Debugging
592  friend class JavaClasses;
593};
594
595// Interface to sun.reflect.ConstantPool objects
596class sun_reflect_ConstantPool {
597 private:
598  // Note that to reduce dependencies on the JDK we compute these
599  // offsets at run-time.
600  static int _cp_oop_offset;
601
602  static void compute_offsets();
603
604 public:
605  // Allocation
606  static Handle create(TRAPS);
607
608  // Accessors
609  static oop cp_oop(oop reflect);
610  static void set_cp_oop(oop reflect, oop value);
611  static int cp_oop_offset() {
612    return _cp_oop_offset;
613  }
614
615  // Debugging
616  friend class JavaClasses;
617};
618
619// Interface to sun.reflect.UnsafeStaticFieldAccessorImpl objects
620class sun_reflect_UnsafeStaticFieldAccessorImpl {
621 private:
622  static int _base_offset;
623  static void compute_offsets();
624
625 public:
626  static int base_offset() {
627    return _base_offset;
628  }
629
630  // Debugging
631  friend class JavaClasses;
632};
633
634// Interface to java.lang primitive type boxing objects:
635//  - java.lang.Boolean
636//  - java.lang.Character
637//  - java.lang.Float
638//  - java.lang.Double
639//  - java.lang.Byte
640//  - java.lang.Short
641//  - java.lang.Integer
642//  - java.lang.Long
643
644// This could be separated out into 8 individual classes.
645
646class java_lang_boxing_object: AllStatic {
647 private:
648  enum {
649   hc_value_offset = 0
650  };
651  static int value_offset;
652
653  static oop initialize_and_allocate(klassOop klass, TRAPS);
654 public:
655  // Allocation. Returns a boxed value, or NULL for invalid type.
656  static oop create(BasicType type, jvalue* value, TRAPS);
657  // Accessors. Returns the basic type being boxed, or T_ILLEGAL for invalid oop.
658  static BasicType get_value(oop box, jvalue* value);
659  static BasicType set_value(oop box, jvalue* value);
660
661  static int value_offset_in_bytes() { return value_offset; }
662
663  // Debugging
664  friend class JavaClasses;
665};
666
667
668
669// Interface to java.lang.ref.Reference objects
670
671class java_lang_ref_Reference: AllStatic {
672 public:
673  enum {
674   hc_referent_offset   = 0,
675   hc_queue_offset      = 1,
676   hc_next_offset       = 2,
677   hc_discovered_offset = 3  // Is not last, see SoftRefs.
678  };
679  enum {
680   hc_static_lock_offset    = 0,
681   hc_static_pending_offset = 1
682  };
683
684  static int referent_offset;
685  static int queue_offset;
686  static int next_offset;
687  static int discovered_offset;
688  static int static_lock_offset;
689  static int static_pending_offset;
690  static int number_of_fake_oop_fields;
691
692  // Accessors
693  static oop referent(oop ref)        { return *referent_addr(ref); }
694  static void set_referent(oop ref, oop value);
695  static oop* referent_addr(oop ref);
696
697  static oop next(oop ref)            { return *next_addr(ref); }
698  static void set_next(oop ref, oop value);
699  static oop* next_addr(oop ref);
700
701  static oop discovered(oop ref)      { return *discovered_addr(ref); }
702  static void set_discovered(oop ref, oop value);
703  static oop* discovered_addr(oop ref);
704
705  // Accessors for statics
706  static oop  pending_list_lock()     { return *pending_list_lock_addr(); }
707  static oop  pending_list()          { return *pending_list_addr(); }
708
709  static oop* pending_list_lock_addr();
710  static oop* pending_list_addr();
711};
712
713
714// Interface to java.lang.ref.SoftReference objects
715
716class java_lang_ref_SoftReference: public java_lang_ref_Reference {
717 public:
718  enum {
719   // The timestamp is a long field and may need to be adjusted for alignment.
720   hc_timestamp_offset    = align_object_offset_(hc_discovered_offset + 1)
721  };
722  enum {
723   hc_static_clock_offset = 0
724  };
725
726  static int timestamp_offset;
727  static int static_clock_offset;
728
729  // Accessors
730  static jlong timestamp(oop ref);
731
732  // Accessors for statics
733  static jlong clock();
734  static void set_clock(jlong value);
735};
736
737
738// Interface to java.security.AccessControlContext objects
739
740class java_security_AccessControlContext: AllStatic {
741 private:
742  // Note that for this class the layout changed between JDK1.2 and JDK1.3,
743  // so we compute the offsets at startup rather than hard-wiring them.
744  static int _context_offset;
745  static int _privilegedContext_offset;
746  static int _isPrivileged_offset;
747
748  static void compute_offsets();
749 public:
750  static oop create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS);
751
752  // Debugging/initialization
753  friend class JavaClasses;
754};
755
756
757// Interface to java.lang.ClassLoader objects
758
759class java_lang_ClassLoader : AllStatic {
760 private:
761  enum {
762   hc_parent_offset = 0
763  };
764
765  static int parent_offset;
766
767 public:
768  static oop parent(oop loader);
769
770  static bool is_trusted_loader(oop loader);
771
772  // Fix for 4474172
773  static oop  non_reflection_class_loader(oop loader);
774
775  // Debugging
776  friend class JavaClasses;
777};
778
779
780// Interface to java.lang.System objects
781
782class java_lang_System : AllStatic {
783 private:
784  enum {
785   hc_static_in_offset  = 0,
786   hc_static_out_offset = 1,
787   hc_static_err_offset = 2
788  };
789
790  static int offset_of_static_fields;
791  static int  static_in_offset;
792  static int static_out_offset;
793  static int static_err_offset;
794
795  static void compute_offsets();
796
797 public:
798  static int  in_offset_in_bytes();
799  static int out_offset_in_bytes();
800  static int err_offset_in_bytes();
801
802  // Debugging
803  friend class JavaClasses;
804};
805
806
807// Interface to java.lang.StackTraceElement objects
808
809class java_lang_StackTraceElement: AllStatic {
810 private:
811  enum {
812    hc_declaringClass_offset  = 0,
813    hc_methodName_offset = 1,
814    hc_fileName_offset   = 2,
815    hc_lineNumber_offset = 3
816  };
817
818  static int declaringClass_offset;
819  static int methodName_offset;
820  static int fileName_offset;
821  static int lineNumber_offset;
822
823 public:
824  // Setters
825  static void set_declaringClass(oop element, oop value);
826  static void set_methodName(oop element, oop value);
827  static void set_fileName(oop element, oop value);
828  static void set_lineNumber(oop element, int value);
829
830  // Create an instance of StackTraceElement
831  static oop create(methodHandle m, int bci, TRAPS);
832
833  // Debugging
834  friend class JavaClasses;
835};
836
837
838// Interface to java.lang.AssertionStatusDirectives objects
839
840class java_lang_AssertionStatusDirectives: AllStatic {
841 private:
842  enum {
843    hc_classes_offset,
844    hc_classEnabled_offset,
845    hc_packages_offset,
846    hc_packageEnabled_offset,
847    hc_deflt_offset
848  };
849
850  static int classes_offset;
851  static int classEnabled_offset;
852  static int packages_offset;
853  static int packageEnabled_offset;
854  static int deflt_offset;
855
856 public:
857  // Setters
858  static void set_classes(oop obj, oop val);
859  static void set_classEnabled(oop obj, oop val);
860  static void set_packages(oop obj, oop val);
861  static void set_packageEnabled(oop obj, oop val);
862  static void set_deflt(oop obj, bool val);
863  // Debugging
864  friend class JavaClasses;
865};
866
867
868class java_nio_Buffer: AllStatic {
869 private:
870  static int _limit_offset;
871
872 public:
873  static int  limit_offset();
874  static void compute_offsets();
875};
876
877class sun_misc_AtomicLongCSImpl: AllStatic {
878 private:
879  static int _value_offset;
880
881 public:
882  static int  value_offset();
883  static void compute_offsets();
884};
885
886class java_util_concurrent_locks_AbstractOwnableSynchronizer : AllStatic {
887 private:
888  static int  _owner_offset;
889 public:
890  static void initialize(TRAPS);
891  static oop  get_owner_threadObj(oop obj);
892};
893
894// Interface to hard-coded offset checking
895
896class JavaClasses : AllStatic {
897 private:
898  static bool check_offset(const char *klass_name, int offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
899  static bool check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
900 public:
901  static void compute_hard_coded_offsets();
902  static void compute_offsets();
903  static void check_offsets() PRODUCT_RETURN;
904};
905