1/*
2 * Copyright (c) 1997, 2017, 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 */
24
25#ifndef SHARE_VM_CLASSFILE_JAVACLASSES_HPP
26#define SHARE_VM_CLASSFILE_JAVACLASSES_HPP
27
28#include "classfile/systemDictionary.hpp"
29#include "jvmtifiles/jvmti.h"
30#include "oops/oop.hpp"
31#include "runtime/os.hpp"
32#include "utilities/utf8.hpp"
33
34// Interface for manipulating the basic Java classes.
35//
36// All dependencies on layout of actual Java classes should be kept here.
37// If the layout of any of the classes above changes the offsets must be adjusted.
38//
39// For most classes we hardwire the offsets for performance reasons. In certain
40// cases (e.g. java.security.AccessControlContext) we compute the offsets at
41// startup since the layout here differs between JDK1.2 and JDK1.3.
42//
43// Note that fields (static and non-static) are arranged with oops before non-oops
44// on a per class basis. The offsets below have to reflect this ordering.
45//
46// When editing the layouts please update the check_offset verification code
47// correspondingly. The names in the enums must be identical to the actual field
48// names in order for the verification code to work.
49
50
51// Interface to java.lang.String objects
52
53class java_lang_String : AllStatic {
54 private:
55  static int value_offset;
56  static int hash_offset;
57  static int coder_offset;
58
59  static bool initialized;
60
61  static Handle basic_create(int length, bool byte_arr, TRAPS);
62
63  static inline void set_coder(oop string, jbyte coder);
64
65 public:
66
67  // Coders
68  enum Coder {
69    CODER_LATIN1 =  0,
70    CODER_UTF16  =  1
71  };
72
73  static void compute_offsets();
74
75  // Instance creation
76  static Handle create_from_unicode(jchar* unicode, int len, TRAPS);
77  static oop    create_oop_from_unicode(jchar* unicode, int len, TRAPS);
78  static Handle create_from_str(const char* utf8_str, TRAPS);
79  static oop    create_oop_from_str(const char* utf8_str, TRAPS);
80  static Handle create_from_symbol(Symbol* symbol, TRAPS);
81  static Handle create_from_platform_dependent_str(const char* str, TRAPS);
82  static Handle char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS);
83
84  static void set_compact_strings(bool value);
85
86  static int value_offset_in_bytes()  {
87    assert(initialized && (value_offset > 0), "Must be initialized");
88    return value_offset;
89  }
90  static int hash_offset_in_bytes()   {
91    assert(initialized && (hash_offset > 0), "Must be initialized");
92    return hash_offset;
93  }
94  static int coder_offset_in_bytes()   {
95    assert(initialized && (coder_offset > 0), "Must be initialized");
96    return coder_offset;
97  }
98
99  static inline void set_value_raw(oop string, typeArrayOop buffer);
100  static inline void set_value(oop string, typeArrayOop buffer);
101  static inline void set_hash(oop string, unsigned int hash);
102
103  // Accessors
104  static inline typeArrayOop value(oop java_string);
105  static inline unsigned int hash(oop java_string);
106  static inline bool is_latin1(oop java_string);
107  static inline int length(oop java_string);
108  static int utf8_length(oop java_string);
109
110  // String converters
111  static char*  as_utf8_string(oop java_string);
112  static char*  as_utf8_string(oop java_string, char* buf, int buflen);
113  static char*  as_utf8_string(oop java_string, int start, int len);
114  static char*  as_utf8_string(oop java_string, int start, int len, char* buf, int buflen);
115  static char*  as_platform_dependent_str(Handle java_string, TRAPS);
116  static jchar* as_unicode_string(oop java_string, int& length, TRAPS);
117  // produce an ascii string with all other values quoted using \u####
118  static char*  as_quoted_ascii(oop java_string);
119
120  // Compute the hash value for a java.lang.String object which would
121  // contain the characters passed in.
122  //
123  // As the hash value used by the String object itself, in
124  // String.hashCode().  This value is normally calculated in Java code
125  // in the String.hashCode method(), but is precomputed for String
126  // objects in the shared archive file.
127  // hash P(31) from Kernighan & Ritchie
128  //
129  // For this reason, THIS ALGORITHM MUST MATCH String.hashCode().
130  static unsigned int hash_code(const jchar* s, int len) {
131    unsigned int h = 0;
132    while (len-- > 0) {
133      h = 31*h + (unsigned int) *s;
134      s++;
135    }
136    return h;
137  }
138
139  static unsigned int hash_code(const jbyte* s, int len) {
140    unsigned int h = 0;
141    while (len-- > 0) {
142      h = 31*h + (((unsigned int) *s) & 0xFF);
143      s++;
144    }
145    return h;
146  }
147
148  static unsigned int hash_code(oop java_string);
149
150  static bool equals(oop java_string, jchar* chars, int len);
151  static bool equals(oop str1, oop str2);
152
153  // Conversion between '.' and '/' formats
154  static Handle externalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '/', '.', THREAD); }
155  static Handle internalize_classname(Handle java_string, TRAPS) { return char_converter(java_string, '.', '/', THREAD); }
156
157  // Conversion
158  static Symbol* as_symbol(Handle java_string, TRAPS);
159  static Symbol* as_symbol_or_null(oop java_string);
160
161  // Testers
162  static bool is_instance(oop obj);
163  static inline bool is_instance_inlined(oop obj);
164
165  // Debugging
166  static void print(oop java_string, outputStream* st);
167  friend class JavaClasses;
168  friend class StringTable;
169};
170
171
172// Interface to java.lang.Class objects
173
174#define CLASS_INJECTED_FIELDS(macro)                                       \
175  macro(java_lang_Class, klass,                  intptr_signature,  false) \
176  macro(java_lang_Class, array_klass,            intptr_signature,  false) \
177  macro(java_lang_Class, oop_size,               int_signature,     false) \
178  macro(java_lang_Class, static_oop_field_count, int_signature,     false) \
179  macro(java_lang_Class, protection_domain,      object_signature,  false) \
180  macro(java_lang_Class, signers,                object_signature,  false)
181
182class java_lang_Class : AllStatic {
183  friend class VMStructs;
184  friend class JVMCIVMStructs;
185
186 private:
187  // The fake offsets are added by the class loader when java.lang.Class is loaded
188
189  static int _klass_offset;
190  static int _array_klass_offset;
191
192  static int _oop_size_offset;
193  static int _static_oop_field_count_offset;
194
195  static int _protection_domain_offset;
196  static int _init_lock_offset;
197  static int _signers_offset;
198  static int _class_loader_offset;
199  static int _module_offset;
200  static int _component_mirror_offset;
201
202  static bool offsets_computed;
203  static int classRedefinedCount_offset;
204
205  static GrowableArray<Klass*>* _fixup_mirror_list;
206  static GrowableArray<Klass*>* _fixup_module_field_list;
207
208  static void set_init_lock(oop java_class, oop init_lock);
209  static void set_protection_domain(oop java_class, oop protection_domain);
210  static void set_class_loader(oop java_class, oop class_loader);
211  static void set_component_mirror(oop java_class, oop comp_mirror);
212  static void initialize_mirror_fields(KlassHandle k, Handle mirror, Handle protection_domain, TRAPS);
213  static void set_mirror_module_field(KlassHandle K, Handle mirror, Handle module, TRAPS);
214 public:
215  static void compute_offsets();
216
217  // Instance creation
218  static void create_mirror(KlassHandle k, Handle class_loader, Handle module,
219                            Handle protection_domain, TRAPS);
220  static void fixup_mirror(KlassHandle k, TRAPS);
221  static oop  create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS);
222
223  static void fixup_module_field(KlassHandle k, Handle module);
224
225  // Conversion
226  static Klass* as_Klass(oop java_class);
227  static void set_klass(oop java_class, Klass* klass);
228  static BasicType as_BasicType(oop java_class, Klass** reference_klass = NULL);
229  static BasicType as_BasicType(oop java_class, KlassHandle* reference_klass) {
230    Klass* refk_oop = NULL;
231    BasicType result = as_BasicType(java_class, &refk_oop);
232    (*reference_klass) = KlassHandle(refk_oop);
233    return result;
234  }
235  static Symbol* as_signature(oop java_class, bool intern_if_not_found, TRAPS);
236  static void print_signature(oop java_class, outputStream *st);
237  static const char* as_external_name(oop java_class);
238  // Testing
239  static bool is_instance(oop obj);
240
241  static bool is_primitive(oop java_class);
242  static BasicType primitive_type(oop java_class);
243  static oop primitive_mirror(BasicType t);
244  // JVM_NewArray support
245  static Klass* array_klass(oop java_class);
246  static void set_array_klass(oop java_class, Klass* klass);
247  // compiler support for class operations
248  static int klass_offset_in_bytes()                { return _klass_offset; }
249  static int array_klass_offset_in_bytes()          { return _array_klass_offset; }
250  // Support for classRedefinedCount field
251  static int classRedefinedCount(oop the_class_mirror);
252  static void set_classRedefinedCount(oop the_class_mirror, int value);
253
254  // Support for embedded per-class oops
255  static oop  protection_domain(oop java_class);
256  static oop  init_lock(oop java_class);
257  static oop  component_mirror(oop java_class);
258  static objArrayOop  signers(oop java_class);
259  static void set_signers(oop java_class, objArrayOop signers);
260
261  static oop class_loader(oop java_class);
262  static void set_module(oop java_class, oop module);
263  static oop module(oop java_class);
264
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);
269
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
277  static GrowableArray<Klass*>* fixup_module_field_list() {
278    return _fixup_module_field_list;
279  }
280  static void set_fixup_module_field_list(GrowableArray<Klass*>* v) {
281    _fixup_module_field_list = v;
282  }
283
284  // Debugging
285  friend class JavaClasses;
286  friend class InstanceKlass;   // verification code accesses offsets
287  friend class ClassFileParser; // access to number_of_fake_fields
288};
289
290// Interface to java.lang.Thread objects
291
292class java_lang_Thread : AllStatic {
293 private:
294  // Note that for this class the layout changed between JDK1.2 and JDK1.3,
295  // so we compute the offsets at startup rather than hard-wiring them.
296  static int _name_offset;
297  static int _group_offset;
298  static int _contextClassLoader_offset;
299  static int _inheritedAccessControlContext_offset;
300  static int _priority_offset;
301  static int _eetop_offset;
302  static int _daemon_offset;
303  static int _stillborn_offset;
304  static int _stackSize_offset;
305  static int _tid_offset;
306  static int _thread_status_offset;
307  static int _park_blocker_offset;
308  static int _park_event_offset ;
309
310  static void compute_offsets();
311
312 public:
313  // Instance creation
314  static oop create();
315  // Returns the JavaThread associated with the thread obj
316  static JavaThread* thread(oop java_thread);
317  // Set JavaThread for instance
318  static void set_thread(oop java_thread, JavaThread* thread);
319  // Name
320  static oop name(oop java_thread);
321  static void set_name(oop java_thread, oop name);
322  // Priority
323  static ThreadPriority priority(oop java_thread);
324  static void set_priority(oop java_thread, ThreadPriority priority);
325  // Thread group
326  static oop  threadGroup(oop java_thread);
327  // Stillborn
328  static bool is_stillborn(oop java_thread);
329  static void set_stillborn(oop java_thread);
330  // Alive (NOTE: this is not really a field, but provides the correct
331  // definition without doing a Java call)
332  static bool is_alive(oop java_thread);
333  // Daemon
334  static bool is_daemon(oop java_thread);
335  static void set_daemon(oop java_thread);
336  // Context ClassLoader
337  static oop context_class_loader(oop java_thread);
338  // Control context
339  static oop inherited_access_control_context(oop java_thread);
340  // Stack size hint
341  static jlong stackSize(oop java_thread);
342  // Thread ID
343  static jlong thread_id(oop java_thread);
344
345  // Blocker object responsible for thread parking
346  static oop park_blocker(oop java_thread);
347
348  // Pointer to type-stable park handler, encoded as jlong.
349  // Should be set when apparently null
350  // For details, see unsafe.cpp Unsafe_Unpark
351  static jlong park_event(oop java_thread);
352  static bool set_park_event(oop java_thread, jlong ptr);
353
354  // Java Thread Status for JVMTI and M&M use.
355  // This thread status info is saved in threadStatus field of
356  // java.lang.Thread java class.
357  enum ThreadStatus {
358    NEW                      = 0,
359    RUNNABLE                 = JVMTI_THREAD_STATE_ALIVE +          // runnable / running
360                               JVMTI_THREAD_STATE_RUNNABLE,
361    SLEEPING                 = JVMTI_THREAD_STATE_ALIVE +          // Thread.sleep()
362                               JVMTI_THREAD_STATE_WAITING +
363                               JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
364                               JVMTI_THREAD_STATE_SLEEPING,
365    IN_OBJECT_WAIT           = JVMTI_THREAD_STATE_ALIVE +          // Object.wait()
366                               JVMTI_THREAD_STATE_WAITING +
367                               JVMTI_THREAD_STATE_WAITING_INDEFINITELY +
368                               JVMTI_THREAD_STATE_IN_OBJECT_WAIT,
369    IN_OBJECT_WAIT_TIMED     = JVMTI_THREAD_STATE_ALIVE +          // Object.wait(long)
370                               JVMTI_THREAD_STATE_WAITING +
371                               JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
372                               JVMTI_THREAD_STATE_IN_OBJECT_WAIT,
373    PARKED                   = JVMTI_THREAD_STATE_ALIVE +          // LockSupport.park()
374                               JVMTI_THREAD_STATE_WAITING +
375                               JVMTI_THREAD_STATE_WAITING_INDEFINITELY +
376                               JVMTI_THREAD_STATE_PARKED,
377    PARKED_TIMED             = JVMTI_THREAD_STATE_ALIVE +          // LockSupport.park(long)
378                               JVMTI_THREAD_STATE_WAITING +
379                               JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT +
380                               JVMTI_THREAD_STATE_PARKED,
381    BLOCKED_ON_MONITOR_ENTER = JVMTI_THREAD_STATE_ALIVE +          // (re-)entering a synchronization block
382                               JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER,
383    TERMINATED               = JVMTI_THREAD_STATE_TERMINATED
384  };
385  // Write thread status info to threadStatus field of java.lang.Thread.
386  static void set_thread_status(oop java_thread_oop, ThreadStatus status);
387  // Read thread status info from threadStatus field of java.lang.Thread.
388  static ThreadStatus get_thread_status(oop java_thread_oop);
389
390  static const char*  thread_status_name(oop java_thread_oop);
391
392  // Debugging
393  friend class JavaClasses;
394};
395
396// Interface to java.lang.ThreadGroup objects
397
398class java_lang_ThreadGroup : AllStatic {
399 private:
400  static int _parent_offset;
401  static int _name_offset;
402  static int _threads_offset;
403  static int _groups_offset;
404  static int _maxPriority_offset;
405  static int _destroyed_offset;
406  static int _daemon_offset;
407  static int _nthreads_offset;
408  static int _ngroups_offset;
409
410  static void compute_offsets();
411
412 public:
413  // parent ThreadGroup
414  static oop  parent(oop java_thread_group);
415  // name
416  static const char* name(oop java_thread_group);
417  // ("name as oop" accessor is not necessary)
418  // Number of threads in group
419  static int nthreads(oop java_thread_group);
420  // threads
421  static objArrayOop threads(oop java_thread_group);
422  // Number of threads in group
423  static int ngroups(oop java_thread_group);
424  // groups
425  static objArrayOop groups(oop java_thread_group);
426  // maxPriority in group
427  static ThreadPriority maxPriority(oop java_thread_group);
428  // Destroyed
429  static bool is_destroyed(oop java_thread_group);
430  // Daemon
431  static bool is_daemon(oop java_thread_group);
432  // Debugging
433  friend class JavaClasses;
434};
435
436
437
438// Interface to java.lang.Throwable objects
439
440class java_lang_Throwable: AllStatic {
441  friend class BacktraceBuilder;
442  friend class BacktraceIterator;
443
444 private:
445  // Offsets
446  enum {
447    hc_backtrace_offset     =  0,
448    hc_detailMessage_offset =  1,
449    hc_cause_offset         =  2,  // New since 1.4
450    hc_stackTrace_offset    =  3   // New since 1.4
451  };
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_cprefs_offset  = 3,
461    trace_next_offset    = 4,
462    trace_size           = 5,
463    trace_chunk_size     = 32
464  };
465
466  static int backtrace_offset;
467  static int detailMessage_offset;
468  static int stackTrace_offset;
469  static int depth_offset;
470  static int static_unassigned_stacktrace_offset;
471
472  // StackTrace (programmatic access, new since 1.4)
473  static void clear_stacktrace(oop throwable);
474  // Stacktrace (post JDK 1.7.0 to allow immutability protocol to be followed)
475  static void set_stacktrace(oop throwable, oop st_element_array);
476  static oop unassigned_stacktrace();
477
478 public:
479  // Backtrace
480  static oop backtrace(oop throwable);
481  static void set_backtrace(oop throwable, oop value);
482  static int depth(oop throwable);
483  static void set_depth(oop throwable, int value);
484  // Needed by JVMTI to filter out this internal field.
485  static int get_backtrace_offset() { return backtrace_offset;}
486  static int get_detailMessage_offset() { return detailMessage_offset;}
487  // Message
488  static oop message(Handle throwable);
489  static void set_message(oop throwable, oop value);
490  static Symbol* detail_message(oop throwable);
491  static void print_stack_element(outputStream *st, const methodHandle& method, int bci);
492  static void print_stack_usage(Handle stream);
493
494  static void compute_offsets();
495
496  // Allocate space for backtrace (created but stack trace not filled in)
497  static void allocate_backtrace(Handle throwable, TRAPS);
498  // Fill in current stack trace for throwable with preallocated backtrace (no GC)
499  static void fill_in_stack_trace_of_preallocated_backtrace(Handle throwable);
500  // Fill in current stack trace, can cause GC
501  static void fill_in_stack_trace(Handle throwable, const methodHandle& method, TRAPS);
502  static void fill_in_stack_trace(Handle throwable, const methodHandle& method = methodHandle());
503  // Programmatic access to stack trace
504  static void get_stack_trace_elements(Handle throwable, objArrayHandle stack_trace, TRAPS);
505  // Printing
506  static void print(Handle throwable, outputStream* st);
507  static void print_stack_trace(Handle throwable, outputStream* st);
508  static void java_printStackTrace(Handle throwable, TRAPS);
509  // Debugging
510  friend class JavaClasses;
511};
512
513
514// Interface to java.lang.reflect.AccessibleObject objects
515
516class java_lang_reflect_AccessibleObject: AllStatic {
517 private:
518  // Note that to reduce dependencies on the JDK we compute these
519  // offsets at run-time.
520  static int override_offset;
521
522  static void compute_offsets();
523
524 public:
525  // Accessors
526  static jboolean override(oop reflect);
527  static void set_override(oop reflect, jboolean value);
528
529  // Debugging
530  friend class JavaClasses;
531};
532
533
534// Interface to java.lang.reflect.Method objects
535
536class java_lang_reflect_Method : public java_lang_reflect_AccessibleObject {
537 private:
538  // Note that to reduce dependencies on the JDK we compute these
539  // offsets at run-time.
540  static int clazz_offset;
541  static int name_offset;
542  static int returnType_offset;
543  static int parameterTypes_offset;
544  static int exceptionTypes_offset;
545  static int slot_offset;
546  static int modifiers_offset;
547  static int signature_offset;
548  static int annotations_offset;
549  static int parameter_annotations_offset;
550  static int annotation_default_offset;
551  static int type_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 method);
564  static void set_name(oop method, oop value);
565
566  static oop return_type(oop method);
567  static void set_return_type(oop method, oop value);
568
569  static oop parameter_types(oop method);
570  static void set_parameter_types(oop method, oop value);
571
572  static oop exception_types(oop method);
573  static void set_exception_types(oop method, oop value);
574
575  static int slot(oop reflect);
576  static void set_slot(oop reflect, int value);
577
578  static int modifiers(oop method);
579  static void set_modifiers(oop method, int value);
580
581  static bool has_signature_field();
582  static oop signature(oop method);
583  static void set_signature(oop method, oop value);
584
585  static bool has_annotations_field();
586  static oop annotations(oop method);
587  static void set_annotations(oop method, oop value);
588
589  static bool has_parameter_annotations_field();
590  static oop parameter_annotations(oop method);
591  static void set_parameter_annotations(oop method, oop value);
592
593  static bool has_annotation_default_field();
594  static oop annotation_default(oop method);
595  static void set_annotation_default(oop method, oop value);
596
597  static bool has_type_annotations_field();
598  static oop type_annotations(oop method);
599  static void set_type_annotations(oop method, oop value);
600
601  // Debugging
602  friend class JavaClasses;
603};
604
605
606// Interface to java.lang.reflect.Constructor objects
607
608class java_lang_reflect_Constructor : public java_lang_reflect_AccessibleObject {
609 private:
610  // Note that to reduce dependencies on the JDK we compute these
611  // offsets at run-time.
612  static int clazz_offset;
613  static int parameterTypes_offset;
614  static int exceptionTypes_offset;
615  static int slot_offset;
616  static int modifiers_offset;
617  static int signature_offset;
618  static int annotations_offset;
619  static int parameter_annotations_offset;
620  static int type_annotations_offset;
621
622  static void compute_offsets();
623
624 public:
625  // Allocation
626  static Handle create(TRAPS);
627
628  // Accessors
629  static oop clazz(oop reflect);
630  static void set_clazz(oop reflect, oop value);
631
632  static oop parameter_types(oop constructor);
633  static void set_parameter_types(oop constructor, oop value);
634
635  static oop exception_types(oop constructor);
636  static void set_exception_types(oop constructor, oop value);
637
638  static int slot(oop reflect);
639  static void set_slot(oop reflect, int value);
640
641  static int modifiers(oop constructor);
642  static void set_modifiers(oop constructor, int value);
643
644  static bool has_signature_field();
645  static oop signature(oop constructor);
646  static void set_signature(oop constructor, oop value);
647
648  static bool has_annotations_field();
649  static oop annotations(oop constructor);
650  static void set_annotations(oop constructor, oop value);
651
652  static bool has_parameter_annotations_field();
653  static oop parameter_annotations(oop method);
654  static void set_parameter_annotations(oop method, oop value);
655
656  static bool has_type_annotations_field();
657  static oop type_annotations(oop constructor);
658  static void set_type_annotations(oop constructor, oop value);
659
660  // Debugging
661  friend class JavaClasses;
662};
663
664
665// Interface to java.lang.reflect.Field objects
666
667class java_lang_reflect_Field : public java_lang_reflect_AccessibleObject {
668 private:
669  // Note that to reduce dependencies on the JDK we compute these
670  // offsets at run-time.
671  static int clazz_offset;
672  static int name_offset;
673  static int type_offset;
674  static int slot_offset;
675  static int modifiers_offset;
676  static int signature_offset;
677  static int annotations_offset;
678  static int type_annotations_offset;
679
680  static void compute_offsets();
681
682 public:
683  // Allocation
684  static Handle create(TRAPS);
685
686  // Accessors
687  static oop clazz(oop reflect);
688  static void set_clazz(oop reflect, oop value);
689
690  static oop name(oop field);
691  static void set_name(oop field, oop value);
692
693  static oop type(oop field);
694  static void set_type(oop field, oop value);
695
696  static int slot(oop reflect);
697  static void set_slot(oop reflect, int value);
698
699  static int modifiers(oop field);
700  static void set_modifiers(oop field, int value);
701
702  static bool has_signature_field();
703  static oop signature(oop constructor);
704  static void set_signature(oop constructor, oop value);
705
706  static bool has_annotations_field();
707  static oop annotations(oop constructor);
708  static void set_annotations(oop constructor, oop value);
709
710  static bool has_parameter_annotations_field();
711  static oop parameter_annotations(oop method);
712  static void set_parameter_annotations(oop method, oop value);
713
714  static bool has_annotation_default_field();
715  static oop annotation_default(oop method);
716  static void set_annotation_default(oop method, oop value);
717
718  static bool has_type_annotations_field();
719  static oop type_annotations(oop field);
720  static void set_type_annotations(oop field, oop value);
721
722  // Debugging
723  friend class JavaClasses;
724};
725
726class java_lang_reflect_Parameter {
727 private:
728  // Note that to reduce dependencies on the JDK we compute these
729  // offsets at run-time.
730  static int name_offset;
731  static int modifiers_offset;
732  static int index_offset;
733  static int executable_offset;
734
735  static void compute_offsets();
736
737 public:
738  // Allocation
739  static Handle create(TRAPS);
740
741  // Accessors
742  static oop name(oop field);
743  static void set_name(oop field, oop value);
744
745  static int index(oop reflect);
746  static void set_index(oop reflect, int value);
747
748  static int modifiers(oop reflect);
749  static void set_modifiers(oop reflect, int value);
750
751  static oop executable(oop constructor);
752  static void set_executable(oop constructor, oop value);
753
754  friend class JavaClasses;
755};
756
757#define MODULE_INJECTED_FIELDS(macro)                            \
758  macro(java_lang_Module, module_entry, intptr_signature, false)
759
760class java_lang_Module {
761  private:
762    static int loader_offset;
763    static int name_offset;
764    static int _module_entry_offset;
765    static void compute_offsets();
766
767  public:
768    // Allocation
769    static Handle create(Handle loader, Handle module_name, TRAPS);
770
771    // Testers
772    static bool is_instance(oop obj);
773
774    // Accessors
775    static oop loader(oop module);
776    static void set_loader(oop module, oop value);
777
778    static oop name(oop module);
779    static void set_name(oop module, oop value);
780
781    static ModuleEntry* module_entry(oop module, TRAPS);
782    static void set_module_entry(oop module, ModuleEntry* module_entry);
783
784  friend class JavaClasses;
785};
786
787// Interface to jdk.internal.reflect.ConstantPool objects
788class reflect_ConstantPool {
789 private:
790  // Note that to reduce dependencies on the JDK we compute these
791  // offsets at run-time.
792  static int _oop_offset;
793
794  static void compute_offsets();
795
796 public:
797  // Allocation
798  static Handle create(TRAPS);
799
800  // Accessors
801  static void set_cp(oop reflect, ConstantPool* value);
802  static int oop_offset() {
803    return _oop_offset;
804  }
805
806  static ConstantPool* get_cp(oop reflect);
807
808  // Debugging
809  friend class JavaClasses;
810};
811
812// Interface to jdk.internal.reflect.UnsafeStaticFieldAccessorImpl objects
813class reflect_UnsafeStaticFieldAccessorImpl {
814 private:
815  static int _base_offset;
816  static void compute_offsets();
817
818 public:
819  static int base_offset() {
820    return _base_offset;
821  }
822
823  // Debugging
824  friend class JavaClasses;
825};
826
827// Interface to java.lang primitive type boxing objects:
828//  - java.lang.Boolean
829//  - java.lang.Character
830//  - java.lang.Float
831//  - java.lang.Double
832//  - java.lang.Byte
833//  - java.lang.Short
834//  - java.lang.Integer
835//  - java.lang.Long
836
837// This could be separated out into 8 individual classes.
838
839class java_lang_boxing_object: AllStatic {
840 private:
841  enum {
842   hc_value_offset = 0
843  };
844  static int value_offset;
845  static int long_value_offset;
846
847  static oop initialize_and_allocate(BasicType type, TRAPS);
848 public:
849  // Allocation. Returns a boxed value, or NULL for invalid type.
850  static oop create(BasicType type, jvalue* value, TRAPS);
851  // Accessors. Returns the basic type being boxed, or T_ILLEGAL for invalid oop.
852  static BasicType get_value(oop box, jvalue* value);
853  static BasicType set_value(oop box, jvalue* value);
854  static BasicType basic_type(oop box);
855  static bool is_instance(oop box)                 { return basic_type(box) != T_ILLEGAL; }
856  static bool is_instance(oop box, BasicType type) { return basic_type(box) == type; }
857  static void print(oop box, outputStream* st)     { jvalue value;  print(get_value(box, &value), &value, st); }
858  static void print(BasicType type, jvalue* value, outputStream* st);
859
860  static int value_offset_in_bytes(BasicType type) {
861    return ( type == T_LONG || type == T_DOUBLE ) ? long_value_offset :
862                                                    value_offset;
863  }
864
865  // Debugging
866  friend class JavaClasses;
867};
868
869
870
871// Interface to java.lang.ref.Reference objects
872
873class java_lang_ref_Reference: AllStatic {
874 public:
875  enum {
876   hc_referent_offset   = 0,
877   hc_queue_offset      = 1,
878   hc_next_offset       = 2,
879   hc_discovered_offset = 3  // Is not last, see SoftRefs.
880  };
881
882  static int referent_offset;
883  static int queue_offset;
884  static int next_offset;
885  static int discovered_offset;
886  static int number_of_fake_oop_fields;
887
888  // Accessors
889  static inline oop referent(oop ref);
890  static inline void set_referent(oop ref, oop value);
891  static inline void set_referent_raw(oop ref, oop value);
892  static inline HeapWord* referent_addr(oop ref);
893  static inline oop next(oop ref);
894  static inline void set_next(oop ref, oop value);
895  static inline void set_next_raw(oop ref, oop value);
896  static inline HeapWord* next_addr(oop ref);
897  static inline oop discovered(oop ref);
898  static inline void set_discovered(oop ref, oop value);
899  static inline void set_discovered_raw(oop ref, oop value);
900  static inline HeapWord* discovered_addr(oop ref);
901};
902
903
904// Interface to java.lang.ref.SoftReference objects
905
906class java_lang_ref_SoftReference: public java_lang_ref_Reference {
907 public:
908  enum {
909   // The timestamp is a long field and may need to be adjusted for alignment.
910   hc_timestamp_offset  = hc_discovered_offset + 1
911  };
912  enum {
913   hc_static_clock_offset = 0
914  };
915
916  static int timestamp_offset;
917  static int static_clock_offset;
918
919  // Accessors
920  static jlong timestamp(oop ref);
921
922  // Accessors for statics
923  static jlong clock();
924  static void set_clock(jlong value);
925};
926
927// Interface to java.lang.invoke.MethodHandle objects
928
929class MethodHandleEntry;
930
931class java_lang_invoke_MethodHandle: AllStatic {
932  friend class JavaClasses;
933
934 private:
935  static int _type_offset;               // the MethodType of this MH
936  static int _form_offset;               // the LambdaForm of this MH
937
938  static void compute_offsets();
939
940 public:
941  // Accessors
942  static oop            type(oop mh);
943  static void       set_type(oop mh, oop mtype);
944
945  static oop            form(oop mh);
946  static void       set_form(oop mh, oop lform);
947
948  // Testers
949  static bool is_subclass(Klass* klass) {
950    return klass->is_subclass_of(SystemDictionary::MethodHandle_klass());
951  }
952  static bool is_instance(oop obj);
953
954  // Accessors for code generation:
955  static int type_offset_in_bytes()             { return _type_offset; }
956  static int form_offset_in_bytes()             { return _form_offset; }
957};
958
959// Interface to java.lang.invoke.DirectMethodHandle objects
960
961class java_lang_invoke_DirectMethodHandle: AllStatic {
962  friend class JavaClasses;
963
964 private:
965  static int _member_offset;               // the MemberName of this DMH
966
967  static void compute_offsets();
968
969 public:
970  // Accessors
971  static oop  member(oop mh);
972
973  // Testers
974  static bool is_subclass(Klass* klass) {
975    return klass->is_subclass_of(SystemDictionary::DirectMethodHandle_klass());
976  }
977  static bool is_instance(oop obj);
978
979  // Accessors for code generation:
980  static int member_offset_in_bytes()           { return _member_offset; }
981};
982
983// Interface to java.lang.invoke.LambdaForm objects
984// (These are a private interface for managing adapter code generation.)
985
986class java_lang_invoke_LambdaForm: AllStatic {
987  friend class JavaClasses;
988
989 private:
990  static int _vmentry_offset;  // type is MemberName
991
992  static void compute_offsets();
993
994 public:
995  // Accessors
996  static oop            vmentry(oop lform);
997  static void       set_vmentry(oop lform, oop invoker);
998
999  // Testers
1000  static bool is_subclass(Klass* klass) {
1001    return SystemDictionary::LambdaForm_klass() != NULL &&
1002      klass->is_subclass_of(SystemDictionary::LambdaForm_klass());
1003  }
1004  static bool is_instance(oop obj);
1005
1006  // Accessors for code generation:
1007  static int vmentry_offset_in_bytes()          { return _vmentry_offset; }
1008};
1009
1010
1011// Interface to java.lang.invoke.MemberName objects
1012// (These are a private interface for Java code to query the class hierarchy.)
1013
1014#define MEMBERNAME_INJECTED_FIELDS(macro)                               \
1015  macro(java_lang_invoke_MemberName, vmloader, object_signature, false) \
1016  macro(java_lang_invoke_MemberName, vmindex,  intptr_signature, false) \
1017  macro(java_lang_invoke_MemberName, vmtarget, intptr_signature, false)
1018
1019class java_lang_invoke_MemberName: AllStatic {
1020  friend class JavaClasses;
1021
1022 private:
1023  // From java.lang.invoke.MemberName:
1024  //    private Class<?>   clazz;       // class in which the method is defined
1025  //    private String     name;        // may be null if not yet materialized
1026  //    private Object     type;        // may be null if not yet materialized
1027  //    private int        flags;       // modifier bits; see reflect.Modifier
1028  //    private intptr     vmtarget;    // VM-specific target value
1029  //    private intptr_t   vmindex;     // member index within class or interface
1030  static int _clazz_offset;
1031  static int _name_offset;
1032  static int _type_offset;
1033  static int _flags_offset;
1034  static int _vmtarget_offset;
1035  static int _vmloader_offset;
1036  static int _vmindex_offset;
1037
1038  static void compute_offsets();
1039
1040 public:
1041  // Accessors
1042  static oop            clazz(oop mname);
1043  static void       set_clazz(oop mname, oop clazz);
1044
1045  static oop            type(oop mname);
1046  static void       set_type(oop mname, oop type);
1047
1048  static oop            name(oop mname);
1049  static void       set_name(oop mname, oop name);
1050
1051  static int            flags(oop mname);
1052  static void       set_flags(oop mname, int flags);
1053
1054  static Metadata*      vmtarget(oop mname);
1055  static void       set_vmtarget(oop mname, Metadata* target);
1056
1057  static intptr_t       vmindex(oop mname);
1058  static void       set_vmindex(oop mname, intptr_t index);
1059
1060  // Testers
1061  static bool is_subclass(Klass* klass) {
1062    return klass->is_subclass_of(SystemDictionary::MemberName_klass());
1063  }
1064  static bool is_instance(oop obj);
1065
1066  static bool is_method(oop obj);
1067
1068  // Relevant integer codes (keep these in synch. with MethodHandleNatives.Constants):
1069  enum {
1070    MN_IS_METHOD            = 0x00010000, // method (not constructor)
1071    MN_IS_CONSTRUCTOR       = 0x00020000, // constructor
1072    MN_IS_FIELD             = 0x00040000, // field
1073    MN_IS_TYPE              = 0x00080000, // nested type
1074    MN_CALLER_SENSITIVE     = 0x00100000, // @CallerSensitive annotation detected
1075    MN_REFERENCE_KIND_SHIFT = 24, // refKind
1076    MN_REFERENCE_KIND_MASK  = 0x0F000000 >> MN_REFERENCE_KIND_SHIFT,
1077    // The SEARCH_* bits are not for MN.flags but for the matchFlags argument of MHN.getMembers:
1078    MN_SEARCH_SUPERCLASSES  = 0x00100000, // walk super classes
1079    MN_SEARCH_INTERFACES    = 0x00200000  // walk implemented interfaces
1080  };
1081
1082  // Accessors for code generation:
1083  static int clazz_offset_in_bytes()            { return _clazz_offset; }
1084  static int type_offset_in_bytes()             { return _type_offset; }
1085  static int name_offset_in_bytes()             { return _name_offset; }
1086  static int flags_offset_in_bytes()            { return _flags_offset; }
1087  static int vmtarget_offset_in_bytes()         { return _vmtarget_offset; }
1088  static int vmindex_offset_in_bytes()          { return _vmindex_offset; }
1089
1090  static bool equals(oop mt1, oop mt2);
1091};
1092
1093
1094// Interface to java.lang.invoke.MethodType objects
1095
1096class java_lang_invoke_MethodType: AllStatic {
1097  friend class JavaClasses;
1098
1099 private:
1100  static int _rtype_offset;
1101  static int _ptypes_offset;
1102
1103  static void compute_offsets();
1104
1105 public:
1106  // Accessors
1107  static oop            rtype(oop mt);
1108  static objArrayOop    ptypes(oop mt);
1109
1110  static oop            ptype(oop mt, int index);
1111  static int            ptype_count(oop mt);
1112
1113  static int            ptype_slot_count(oop mt);  // extra counts for long/double
1114  static int            rtype_slot_count(oop mt);  // extra counts for long/double
1115
1116  static Symbol*        as_signature(oop mt, bool intern_if_not_found, TRAPS);
1117  static void           print_signature(oop mt, outputStream* st);
1118
1119  static bool is_instance(oop obj);
1120
1121  static bool equals(oop mt1, oop mt2);
1122
1123  // Accessors for code generation:
1124  static int rtype_offset_in_bytes()            { return _rtype_offset; }
1125  static int ptypes_offset_in_bytes()           { return _ptypes_offset; }
1126};
1127
1128
1129// Interface to java.lang.invoke.CallSite objects
1130
1131class java_lang_invoke_CallSite: AllStatic {
1132  friend class JavaClasses;
1133
1134private:
1135  static int _target_offset;
1136  static int _context_offset;
1137
1138  static void compute_offsets();
1139
1140public:
1141  // Accessors
1142  static oop              target(          oop site);
1143  static void         set_target(          oop site, oop target);
1144  static void         set_target_volatile( oop site, oop target);
1145
1146  static oop              context(oop site);
1147
1148  // Testers
1149  static bool is_subclass(Klass* klass) {
1150    return klass->is_subclass_of(SystemDictionary::CallSite_klass());
1151  }
1152  static bool is_instance(oop obj);
1153
1154  // Accessors for code generation:
1155  static int target_offset_in_bytes()           { return _target_offset; }
1156};
1157
1158// Interface to java.lang.invoke.MethodHandleNatives$CallSiteContext objects
1159
1160#define CALLSITECONTEXT_INJECTED_FIELDS(macro) \
1161  macro(java_lang_invoke_MethodHandleNatives_CallSiteContext, vmdependencies, intptr_signature, false)
1162
1163class DependencyContext;
1164
1165class java_lang_invoke_MethodHandleNatives_CallSiteContext : AllStatic {
1166  friend class JavaClasses;
1167
1168private:
1169  static int _vmdependencies_offset;
1170
1171  static void compute_offsets();
1172
1173public:
1174  // Accessors
1175  static DependencyContext vmdependencies(oop context);
1176
1177  // Testers
1178  static bool is_subclass(Klass* klass) {
1179    return klass->is_subclass_of(SystemDictionary::Context_klass());
1180  }
1181  static bool is_instance(oop obj);
1182};
1183
1184// Interface to java.security.AccessControlContext objects
1185
1186class java_security_AccessControlContext: AllStatic {
1187 private:
1188  // Note that for this class the layout changed between JDK1.2 and JDK1.3,
1189  // so we compute the offsets at startup rather than hard-wiring them.
1190  static int _context_offset;
1191  static int _privilegedContext_offset;
1192  static int _isPrivileged_offset;
1193  static int _isAuthorized_offset;
1194
1195  static void compute_offsets();
1196 public:
1197  static oop create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS);
1198
1199  static bool is_authorized(Handle context);
1200
1201  // Debugging/initialization
1202  friend class JavaClasses;
1203};
1204
1205
1206// Interface to java.lang.ClassLoader objects
1207
1208#define CLASSLOADER_INJECTED_FIELDS(macro)                            \
1209  macro(java_lang_ClassLoader, loader_data,  intptr_signature, false)
1210
1211class java_lang_ClassLoader : AllStatic {
1212 private:
1213  // The fake offsets are added by the class loader when java.lang.Class is loaded
1214  enum {
1215   hc_parent_offset = 0
1216  };
1217  static int _loader_data_offset;
1218  static bool offsets_computed;
1219  static int parent_offset;
1220  static int parallelCapable_offset;
1221  static int name_offset;
1222  static int unnamedModule_offset;
1223
1224 public:
1225  static void compute_offsets();
1226
1227  static ClassLoaderData** loader_data_addr(oop loader);
1228  static ClassLoaderData* loader_data(oop loader);
1229
1230  static oop parent(oop loader);
1231  static oop name(oop loader);
1232  static bool isAncestor(oop loader, oop cl);
1233
1234  // Support for parallelCapable field
1235  static bool parallelCapable(oop the_class_mirror);
1236
1237  static bool is_trusted_loader(oop loader);
1238
1239  // Return true if this is one of the class loaders associated with
1240  // the generated bytecodes for reflection.
1241  static bool is_reflection_class_loader(oop loader);
1242
1243  // Fix for 4474172
1244  static oop  non_reflection_class_loader(oop loader);
1245
1246  // Testers
1247  static bool is_subclass(Klass* klass) {
1248    return klass->is_subclass_of(SystemDictionary::ClassLoader_klass());
1249  }
1250  static bool is_instance(oop obj);
1251
1252  static oop unnamedModule(oop loader);
1253
1254  // Debugging
1255  friend class JavaClasses;
1256  friend class ClassFileParser; // access to number_of_fake_fields
1257};
1258
1259
1260// Interface to java.lang.System objects
1261
1262class java_lang_System : AllStatic {
1263 private:
1264  enum {
1265   hc_static_in_offset  = 0,
1266   hc_static_out_offset = 1,
1267   hc_static_err_offset = 2,
1268   hc_static_security_offset = 3
1269  };
1270
1271  static int  static_in_offset;
1272  static int static_out_offset;
1273  static int static_err_offset;
1274  static int static_security_offset;
1275
1276 public:
1277  static int  in_offset_in_bytes();
1278  static int out_offset_in_bytes();
1279  static int err_offset_in_bytes();
1280
1281  static bool has_security_manager();
1282
1283  // Debugging
1284  friend class JavaClasses;
1285};
1286
1287
1288// Interface to java.lang.StackTraceElement objects
1289
1290class java_lang_StackTraceElement: AllStatic {
1291 private:
1292  enum {
1293    hc_declaringClassObject_offset    = 0,
1294    hc_classLoaderName_offset      = 1,
1295    hc_moduleName_offset           = 2,
1296    hc_moduleVersion_offset        = 3,
1297    hc_declaringClass_offset       = 4,
1298    hc_methodName_offset           = 5,
1299    hc_fileName_offset             = 6,
1300    hc_lineNumber_offset           = 7
1301  };
1302
1303  static int declaringClassObject_offset;
1304  static int classLoaderName_offset;
1305  static int moduleName_offset;
1306  static int moduleVersion_offset;
1307  static int declaringClass_offset;
1308  static int methodName_offset;
1309  static int fileName_offset;
1310  static int lineNumber_offset;
1311
1312  // Setters
1313  static void set_classLoaderName(oop element, oop value);
1314  static void set_moduleName(oop element, oop value);
1315  static void set_moduleVersion(oop element, oop value);
1316  static void set_declaringClass(oop element, oop value);
1317  static void set_methodName(oop element, oop value);
1318  static void set_fileName(oop element, oop value);
1319  static void set_lineNumber(oop element, int value);
1320  static void set_declaringClassObject(oop element, oop value);
1321
1322 public:
1323  // Create an instance of StackTraceElement
1324  static oop create(const methodHandle& method, int bci, TRAPS);
1325
1326  static void fill_in(Handle element, InstanceKlass* holder, const methodHandle& method,
1327                      int version, int bci, int cpref, TRAPS);
1328
1329  // Debugging
1330  friend class JavaClasses;
1331};
1332
1333
1334class Backtrace: AllStatic {
1335 public:
1336  // Helper backtrace functions to store bci|version together.
1337  static int merge_bci_and_version(int bci, int version);
1338  static int merge_mid_and_cpref(int mid, int cpref);
1339  static int bci_at(unsigned int merged);
1340  static int version_at(unsigned int merged);
1341  static int mid_at(unsigned int merged);
1342  static int cpref_at(unsigned int merged);
1343  static int get_line_number(const methodHandle& method, int bci);
1344  static Symbol* get_source_file_name(InstanceKlass* holder, int version);
1345
1346  // Debugging
1347  friend class JavaClasses;
1348};
1349
1350// Interface to java.lang.StackFrameInfo objects
1351
1352#define STACKFRAMEINFO_INJECTED_FIELDS(macro)                      \
1353  macro(java_lang_StackFrameInfo, version, short_signature, false)
1354
1355class java_lang_StackFrameInfo: AllStatic {
1356private:
1357  static int _declaringClass_offset;
1358  static int _memberName_offset;
1359  static int _bci_offset;
1360  static int _version_offset;
1361
1362  static Method* get_method(Handle stackFrame, InstanceKlass* holder, TRAPS);
1363
1364public:
1365  // Setters
1366  static void set_declaringClass(oop info, oop value);
1367  static void set_method_and_bci(Handle stackFrame, const methodHandle& method, int bci);
1368  static void set_bci(oop info, int value);
1369
1370  static void set_version(oop info, short value);
1371
1372  static void compute_offsets();
1373
1374  static void to_stack_trace_element(Handle stackFrame, Handle stack_trace_element, TRAPS);
1375
1376  // Debugging
1377  friend class JavaClasses;
1378};
1379
1380class java_lang_LiveStackFrameInfo: AllStatic {
1381 private:
1382  static int _monitors_offset;
1383  static int _locals_offset;
1384  static int _operands_offset;
1385  static int _mode_offset;
1386
1387 public:
1388  static void set_monitors(oop info, oop value);
1389  static void set_locals(oop info, oop value);
1390  static void set_operands(oop info, oop value);
1391  static void set_mode(oop info, int value);
1392
1393  static void compute_offsets();
1394
1395  // Debugging
1396  friend class JavaClasses;
1397};
1398
1399// Interface to java.lang.AssertionStatusDirectives objects
1400
1401class java_lang_AssertionStatusDirectives: AllStatic {
1402 private:
1403  enum {
1404    hc_classes_offset,
1405    hc_classEnabled_offset,
1406    hc_packages_offset,
1407    hc_packageEnabled_offset,
1408    hc_deflt_offset
1409  };
1410
1411  static int classes_offset;
1412  static int classEnabled_offset;
1413  static int packages_offset;
1414  static int packageEnabled_offset;
1415  static int deflt_offset;
1416
1417 public:
1418  // Setters
1419  static void set_classes(oop obj, oop val);
1420  static void set_classEnabled(oop obj, oop val);
1421  static void set_packages(oop obj, oop val);
1422  static void set_packageEnabled(oop obj, oop val);
1423  static void set_deflt(oop obj, bool val);
1424  // Debugging
1425  friend class JavaClasses;
1426};
1427
1428
1429class java_nio_Buffer: AllStatic {
1430 private:
1431  static int _limit_offset;
1432
1433 public:
1434  static int  limit_offset();
1435  static void compute_offsets();
1436};
1437
1438class java_util_concurrent_locks_AbstractOwnableSynchronizer : AllStatic {
1439 private:
1440  static int  _owner_offset;
1441 public:
1442  static void initialize(TRAPS);
1443  static oop  get_owner_threadObj(oop obj);
1444};
1445
1446// Use to declare fields that need to be injected into Java classes
1447// for the JVM to use.  The name_index and signature_index are
1448// declared in vmSymbols.  The may_be_java flag is used to declare
1449// fields that might already exist in Java but should be injected if
1450// they don't.  Otherwise the field is unconditionally injected and
1451// the JVM uses the injected one.  This is to ensure that name
1452// collisions don't occur.  In general may_be_java should be false
1453// unless there's a good reason.
1454
1455class InjectedField {
1456 public:
1457  const SystemDictionary::WKID klass_id;
1458  const vmSymbols::SID name_index;
1459  const vmSymbols::SID signature_index;
1460  const bool           may_be_java;
1461
1462
1463  Klass* klass() const    { return SystemDictionary::well_known_klass(klass_id); }
1464  Symbol* name() const      { return lookup_symbol(name_index); }
1465  Symbol* signature() const { return lookup_symbol(signature_index); }
1466
1467  int compute_offset();
1468
1469  // Find the Symbol for this index
1470  static Symbol* lookup_symbol(int symbol_index) {
1471    return vmSymbols::symbol_at((vmSymbols::SID)symbol_index);
1472  }
1473};
1474
1475#define DECLARE_INJECTED_FIELD_ENUM(klass, name, signature, may_be_java) \
1476  klass##_##name##_enum,
1477
1478#define ALL_INJECTED_FIELDS(macro)          \
1479  CLASS_INJECTED_FIELDS(macro)              \
1480  CLASSLOADER_INJECTED_FIELDS(macro)        \
1481  MEMBERNAME_INJECTED_FIELDS(macro)         \
1482  CALLSITECONTEXT_INJECTED_FIELDS(macro)    \
1483  STACKFRAMEINFO_INJECTED_FIELDS(macro)     \
1484  MODULE_INJECTED_FIELDS(macro)
1485
1486// Interface to hard-coded offset checking
1487
1488class JavaClasses : AllStatic {
1489 private:
1490
1491  static InjectedField _injected_fields[];
1492
1493  static bool check_offset(const char *klass_name, int offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
1494  static bool check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
1495  static bool check_constant(const char *klass_name, int constant, const char *field_name, const char* field_sig) PRODUCT_RETURN0;
1496
1497 public:
1498  enum InjectedFieldID {
1499    ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD_ENUM)
1500    MAX_enum
1501  };
1502
1503  static int compute_injected_offset(InjectedFieldID id);
1504
1505  static void compute_hard_coded_offsets();
1506  static void compute_offsets();
1507  static void check_offsets() PRODUCT_RETURN;
1508
1509  static InjectedField* get_injected(Symbol* class_name, int* field_count);
1510};
1511
1512#undef DECLARE_INJECTED_FIELD_ENUM
1513
1514#endif // SHARE_VM_CLASSFILE_JAVACLASSES_HPP
1515